package com.sg.service.biz.app.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.biz.app.req.*;
import com.sg.dto.biz.app.res.*;
import com.sg.service.base.app.MOmsEvaBatchRelatedSetService;
import com.sg.service.biz.app.MessageService;
import com.sg.service.biz.app.QuestionService;
import com.sg.service.biz.app.WorkTasksService;
import com.sg.common.exception.Assert;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrcomponent.integration.*;
import com.wicket.okrcomponent.integration.dto.*;
import com.wicket.okrframework.integration.*;
import com.wicket.okrframework.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.stream.Collectors;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class IntelligentCommunicationServiceImpl
        implements com.wicket.okrapp.biz.service.IntelligentCommunicationService {

    @Resource
    private RedisUtil redisUtil;
    //@Resource
    //private MMmmShellService mMmmShellService;
    @Resource
    private NbIntelligentCommunication nbIntelligentCommunication;
    @Resource
    private OrgService orgService;
    @Resource
    private ConfSchemeService confSchemeService;
    @Resource
    private TemplateEngineService fwCompTemplateEngineClient;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private IntelligentCommunicationService fwCompIntelligentCommunicationClient;
    @Resource
    private InductionRecordService inductionRecordService;
    @Resource
    private UserService fwBaseUserClient;
    @Resource
    private QuestionService questionService;
    @Resource
    private WorkTasksService workTasksService;
    @Resource
    private MOmsEvaBatchRelatedSetService mOmsEvaBatchRelatedSetService;
    @Resource
    private BaseService baseService;
    @Resource
    private MemberService fwBaseMemberClient;
    @Resource
    private MessageService fwCompMessageClient;
    //@Resource
    //private MCustomFields4Service mCustomFields4Service;
    @Resource
    private MessageService messageService;
//@Resource
    //private MSpecMethordTableService mSpecMethordTableService;

    /**
     * D3执行智能指令沟通服务(公共)[8102]
     * gen by moon at 12/13/2024, 11:13:11 PM
     */
    @Trace(operationName = "D3执行智能指令沟通服务(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementIntelligentCommandCommunicationServicesComRespDto implementIntelligentCommandCommunicationServicesCom(ImplementIntelligentCommandCommunicationServicesComReqDto reqDto) {


        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_3 = null;
//virtualUsage M3-约定新增问题任务成功文案  56439
        //ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes = null;
        ImplementAcceptFieldByStandardDataReqDto receptionServiceReq = new ImplementAcceptFieldByStandardDataReqDto();
        receptionServiceReq.setCustomField1("您提出的问题已成功～");//CUSTOM_CONVENTION//sourceId:1404693_1_56439
        receptionServiceReq.setCustomField2("您安排的任务已成功～");//CUSTOM_CONVENTION//sourceId:1404694_1_56439
        receptionServiceReq.setCustomField3("您的想法记录成功，创新的人最有魅力！");//CUSTOM_CONVENTION//sourceId:1479342_1_56439
        receptionServiceReq.setCustomField4("您的笔记记录成功，细心的人最有魅力！");//CUSTOM_CONVENTION//sourceId:1495358_1_56439

        /*M3-约定新增问题任务成功文案[7478]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getCustomField1(), "D3执行智能指令沟通服务(公共)-M3-约定新增问题任务成功文案-自定义字段1不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField2(), "D3执行智能指令沟通服务(公共)-M3-约定新增问题任务成功文案-自定义字段2不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField3(), "D3执行智能指令沟通服务(公共)-M3-约定新增问题任务成功文案-自定义字段3不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField4(), "D3执行智能指令沟通服务(公共)-M3-约定新增问题任务成功文案-自定义字段4不能为空", false);
        receptionServiceRes = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq);


//virtualUsage D1执行设备获取组织个人信息(公共)  56344
        ImplementDeviceAcquisitionOrgPersonalInfoComRespDto implementDeviceAcquisitionOrgPersonalInfoComRespDto = null;
        ImplementDeviceAcquisitionOrgPersonalInfoComReqDto implementDeviceAcquisitionOrgPersonalInfoComReqDto = new ImplementDeviceAcquisitionOrgPersonalInfoComReqDto();
        if (reqDto != null) {
            implementDeviceAcquisitionOrgPersonalInfoComReqDto.setSn(reqDto.getSn());//SimpleFieldAssign//sourceId:1401762_1_56344
            implementDeviceAcquisitionOrgPersonalInfoComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1401763_1_56344
            implementDeviceAcquisitionOrgPersonalInfoComReqDto.setApiKey(reqDto.getApiKey());//SimpleFieldAssign//sourceId:1401764_1_56344
            implementDeviceAcquisitionOrgPersonalInfoComReqDto.setApiSecret(reqDto.getApiSecret());//SimpleFieldAssign//sourceId:1401765_1_56344
        }

        /*D1执行设备获取组织个人信息(公共)[8108]   */
        Assert.isNull(implementDeviceAcquisitionOrgPersonalInfoComReqDto.getAppId(), "D3执行智能指令沟通服务(公共)-D1执行设备获取组织个人信息(公共)-应用ID不能为空", false);
        Assert.isNull(implementDeviceAcquisitionOrgPersonalInfoComReqDto.getApiKey(), "D3执行智能指令沟通服务(公共)-D1执行设备获取组织个人信息(公共)-应用key不能为空", false);
        Assert.isNull(implementDeviceAcquisitionOrgPersonalInfoComReqDto.getApiSecret(), "D3执行智能指令沟通服务(公共)-D1执行设备获取组织个人信息(公共)-应用密码不能为空", false);
        implementDeviceAcquisitionOrgPersonalInfoComRespDto = orgService.implementDeviceAcquisitionOrgPersonalInfoCom(implementDeviceAcquisitionOrgPersonalInfoComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D1查询就职的部门详情(公共)  56426
        QueryInductionDeptDetailComRespDto queryInductionDeptDetailComRespDto = null;
        if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
            QueryInductionDeptDetailComReqDto queryInductionDeptDetailComReqDto = new QueryInductionDeptDetailComReqDto();
            queryInductionDeptDetailComReqDto.setInductionUnitTypeCode("DEPT");//sourceId:1403614_1_56426
            queryInductionDeptDetailComReqDto.setIsMainInduction("TRUE");//sourceId:1402946_1_56426
            queryInductionDeptDetailComReqDto.setIsTransaction("FALSE");//sourceId:1402947_1_56426
            queryInductionDeptDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1402948_1_56426
            if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                queryInductionDeptDetailComReqDto.setUserId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403654_1_56426
                queryInductionDeptDetailComReqDto.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1402929_1_56426
            }

            /*D1查询就职的部门详情(公共)[7829]   */
            Assert.isNull(queryInductionDeptDetailComReqDto.getUserId(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-个人账号ID不能为空", false);
            Assert.isNull(queryInductionDeptDetailComReqDto.getInductionUnitTypeCode(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-就职单位类型实例不能为空", false);
            Assert.isNull(queryInductionDeptDetailComReqDto.getIsMainInduction(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-是否主岗不能为空", false);
            Assert.isNull(queryInductionDeptDetailComReqDto.getIsTransaction(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-是否异动不能为空", false);
            Assert.isNull(queryInductionDeptDetailComReqDto.getSubjectLifeCycle(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-主体生命周期不能为空", false);
            Assert.isNull(queryInductionDeptDetailComReqDto.getSpaceId(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-创建于空间ID不能为空", false);
            queryInductionDeptDetailComRespDto = inductionRecordService.queryInductionDeptDetailCom(queryInductionDeptDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
//virtualUsage M3推内存  56427
        //ModelCode: publicFieldCache
        ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
        if (queryInductionDeptDetailComRespDto != null && implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
            ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq = new ImplementBizPublicFieldPushMemoryReqDto();
            if (queryInductionDeptDetailComRespDto != null) {
                publicFieldCacheReq.setCreateInductionId(queryInductionDeptDetailComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:1403997_1_56427
            }
            if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                publicFieldCacheReq.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1403998_1_56427
                publicFieldCacheReq.setAppId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getAppId());//SimpleFieldAssign//sourceId:1403999_1_56427
            }

            /*M3推内存[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */

            publicFieldCacheRes = nbIntelligentCommunication.implementBizPublicFieldPushMemory(publicFieldCacheReq);


        }
//virtualUsage D2查询用于智能问答的指令模板  56345
        QueryConfItemDetailComRespDto queryConfItemDetailComRespDto = null;
        QueryConfItemDetailComReqDto queryConfItemDetailComReqDto = new QueryConfItemDetailComReqDto();
        queryConfItemDetailComReqDto.setConfItemCode("THIRD_QA_SYSTEM");//CUSTOM_CONVENTION//sourceId:1396844_1_56345
        queryConfItemDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1396845_1_56345

        /*D2查询用于智能问答的指令模板[8110]   */
        Assert.isNull(queryConfItemDetailComReqDto.getConfItemCode(), "D3执行智能指令沟通服务(公共)-D2查询用于智能问答的指令模板-配置项标识不能为空", false);
        Assert.isNull(queryConfItemDetailComReqDto.getSubjectLifeCycle(), "D3执行智能指令沟通服务(公共)-D2查询用于智能问答的指令模板-主体生命周期不能为空", false);
        queryConfItemDetailComRespDto = confSchemeService.queryConfItemDetailCom(queryConfItemDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
        Assert.isTrue(queryConfItemDetailComRespDto == null || queryConfItemDetailComRespDto.getConfItemDes() == null, "找不到数据，系统异常", false);


//virtualUsage D2执行组装指令模板提问内容  56346
        ImplementRoboticSceneSemanticEngineComRespDto implementRoboticSceneSemanticEngineComRespDto = null;
        if (queryConfItemDetailComRespDto != null) {
            ImplementRoboticSceneSemanticEngineComReqDto implementRoboticSceneSemanticEngineComReqDto = new ImplementRoboticSceneSemanticEngineComReqDto();
            implementRoboticSceneSemanticEngineComReqDto.setTemplateSemanticEngineCode("ASSEMBLY_INSTRUCTION_QUS_CONT_TEMP");//CUSTOM_CONVENTION//sourceId:1401770_1_56346
            if (reqDto != null) {
                implementRoboticSceneSemanticEngineComReqDto.setContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1401771_1_56346
            }
            if (queryConfItemDetailComRespDto != null) {
                implementRoboticSceneSemanticEngineComReqDto.setInstructionTemplate(queryConfItemDetailComRespDto.getConfItemDes());//SimpleFieldAssign//sourceId:1401772_1_56346
            }

            /*D2执行组装指令模板提问内容[8112]   */
            Assert.isNull(implementRoboticSceneSemanticEngineComReqDto.getTemplateSemanticEngineCode(), "D3执行智能指令沟通服务(公共)-D2执行组装指令模板提问内容-模板引擎标识不能为空", false);
            Assert.isNull(implementRoboticSceneSemanticEngineComReqDto.getContent(), "D3执行智能指令沟通服务(公共)-D2执行组装指令模板提问内容-消息内容不能为空", false);
            Assert.isNull(implementRoboticSceneSemanticEngineComReqDto.getInstructionTemplate(), "D3执行智能指令沟通服务(公共)-D2执行组装指令模板提问内容-指令模板部分内容不能为空", false);
            implementRoboticSceneSemanticEngineComRespDto = fwCompTemplateEngineClient.implementRoboticSceneSemanticEngineCom(implementRoboticSceneSemanticEngineComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
            Assert.isTrue(implementRoboticSceneSemanticEngineComRespDto == null || implementRoboticSceneSemanticEngineComRespDto.getObjectName() == null, "找不到数据，系统异常", false);


        }
//virtualUsage D2执行输入消息内容单字段转数据集  56358
        ImplementMutDataToOneDatasComRespDto implementMutDataToOneDatasComRespDto = null;
        if (implementRoboticSceneSemanticEngineComRespDto != null) {
            ImplementMutDataToOneDatasComReqDto implementMutDataToOneDatasComReqDto = new ImplementMutDataToOneDatasComReqDto();
            if (implementRoboticSceneSemanticEngineComRespDto != null) {
                implementMutDataToOneDatasComReqDto.setCustomField(implementRoboticSceneSemanticEngineComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1400663_1_56358
            }

            /*D2执行输入消息内容单字段转数据集[5864]   */
            Assert.isNull(implementMutDataToOneDatasComReqDto.getCustomField(), "D3执行智能指令沟通服务(公共)-D2执行输入消息内容单字段转数据集-自定义字段不能为空", false);
            implementMutDataToOneDatasComRespDto = interfaceModeService.implementMutDataToOneDatasCom(implementMutDataToOneDatasComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
//virtualUsage D2执行导向第三方智能问答(公共)  56357
        ImplementGuidedThirdPartyIntelligentQaComRespDto implementGuidedThirdPartyIntelligentQaComRespDto = null;
        if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null && implementMutDataToOneDatasComRespDto != null) {
            ImplementGuidedThirdPartyIntelligentQaComReqDto implementGuidedThirdPartyIntelligentQaComReqDto = new ImplementGuidedThirdPartyIntelligentQaComReqDto();
            implementGuidedThirdPartyIntelligentQaComReqDto.setBusModelVersion("PLUS_VERSION");//sourceId:2036980_1_56357
            if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                implementGuidedThirdPartyIntelligentQaComReqDto.setResultAspObjId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1400587_1_56357
            }
            if (implementMutDataToOneDatasComRespDto != null) {
                //simpleList-to-objLists
                for (String item : implementMutDataToOneDatasComRespDto.getComDatasList()) {
                    GetListIntelligentAnswersDto oneItem = new GetListIntelligentAnswersDto();
                    oneItem.setRole("user");//sourceId:282040_2_56357
                    if (implementMutDataToOneDatasComRespDto != null) {
                        oneItem.setContent(item);//SimpleFieldAssign//sourceId:282039_2_56357
                    }

                    implementGuidedThirdPartyIntelligentQaComReqDto.getGetListIntelligentAnswersList().add(oneItem);
                }//sourceId:1400588_1_56357
            }

            /*D2执行导向第三方智能问答(公共)[8103]   */
            Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto.getResultAspObjId(), "D3执行智能指令沟通服务(公共)-D2执行导向第三方智能问答(公共)-开通对象ID不能为空", false);
            Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto.getBusModelVersion(), "D3执行智能指令沟通服务(公共)-D2执行导向第三方智能问答(公共)-业务模型版本不能为空", false);
            implementGuidedThirdPartyIntelligentQaComRespDto = fwCompIntelligentCommunicationClient.implementGuidedThirdPartyIntelligentQaCom(implementGuidedThirdPartyIntelligentQaComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
            Assert.isTrue(implementGuidedThirdPartyIntelligentQaComRespDto == null || implementGuidedThirdPartyIntelligentQaComRespDto.getContent() == null || implementGuidedThirdPartyIntelligentQaComRespDto == null || implementGuidedThirdPartyIntelligentQaComRespDto.getRole() == null, "找不到数据，系统异常", false);


        }
//virtualUsage D2执行人工解析指令参数(公共)  56347
        ImplementManuallyParsingInstructionParametersComRespDto implementManuallyParsingInstructionParametersComRespDto = null;
        if (implementGuidedThirdPartyIntelligentQaComRespDto != null) {
            ImplementManuallyParsingInstructionParametersComReqDto implementManuallyParsingInstructionParametersComReqDto = new ImplementManuallyParsingInstructionParametersComReqDto();
            if (implementGuidedThirdPartyIntelligentQaComRespDto != null) {
                implementManuallyParsingInstructionParametersComReqDto.setContent(implementGuidedThirdPartyIntelligentQaComRespDto.getContent());//SimpleFieldAssign//sourceId:1400664_1_56347
            }

            /*D2执行人工解析指令参数(公共)[8104]   */
            Assert.isNull(implementManuallyParsingInstructionParametersComReqDto.getContent(), "D3执行智能指令沟通服务(公共)-D2执行人工解析指令参数(公共)-消息内容不能为空", false);
            implementManuallyParsingInstructionParametersComRespDto = fwCompIntelligentCommunicationClient.implementManuallyParsingInstructionParametersCom(implementManuallyParsingInstructionParametersComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        if ((implementManuallyParsingInstructionParametersComRespDto != null && implementManuallyParsingInstructionParametersComRespDto.getCustomField() != null && implementManuallyParsingInstructionParametersComRespDto.getCustomField().equals("IMPORT_WORK_REMIND"))) {
            //if(D2执行人工解析指令参数(公共).自定义字段 等于 了解重要工作提醒)  56348

            ImplementStrongReminderListComRespDto implementStrongReminderListComRespDto = null;
            if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                ImplementStrongReminderListComReqDto implementStrongReminderListComReqDto = new ImplementStrongReminderListComReqDto();
                implementStrongReminderListComReqDto.setMessageImportantLevel(Long.valueOf(3));//CUSTOM_CONVENTION//sourceId:1400701_1_56359
                implementStrongReminderListComReqDto.setIsRead("FALSE");//sourceId:1400702_1_56359
                if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                    implementStrongReminderListComReqDto.setOriginalRoleMemberId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1400699_1_56359
                    implementStrongReminderListComReqDto.setUserId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getUserId());//SimpleFieldAssign//sourceId:1400700_1_56359
                    implementStrongReminderListComReqDto.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1400703_1_56359
                }

                /*D2执行强提醒列表(公共)[8106]   */
                Assert.isNull(implementStrongReminderListComReqDto.getOriginalRoleMemberId(), "D3执行智能指令沟通服务(公共)-D2执行强提醒列表(公共)-所属身份人员ID不能为空", false);
                Assert.isNull(implementStrongReminderListComReqDto.getUserId(), "D3执行智能指令沟通服务(公共)-D2执行强提醒列表(公共)-所属个人账号ID不能为空", false);
                Assert.isNull(implementStrongReminderListComReqDto.getMessageImportantLevel(), "D3执行智能指令沟通服务(公共)-D2执行强提醒列表(公共)-消息重要紧急度层级不能为空", false);
                Assert.isNull(implementStrongReminderListComReqDto.getIsRead(), "D3执行智能指令沟通服务(公共)-D2执行强提醒列表(公共)-是否已读不能为空", false);
                Assert.isNull(implementStrongReminderListComReqDto.getSpaceId(), "D3执行智能指令沟通服务(公共)-D2执行强提醒列表(公共)-创建于空间ID不能为空", false);
                implementStrongReminderListComRespDto = fwCompIntelligentCommunicationClient.implementStrongReminderListCom(implementStrongReminderListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementStrongReminderListComRespDto != null && implementStrongReminderListComRespDto.getMessageList() != null && implementStrongReminderListComRespDto.getMessageList().size() == 0)) {
                //if(D2执行强提醒列表(公共).消息列表数据集条数 等于 0)  59113

//异常结束 59116
                throw new BizException("C00276", "您没有最新提醒，请与我说其他内容～", false);
            }
            ImplementDataAppointFormatShiftTextComRespDto implementDataAppointFormatShiftTextComRespDto = null;
            if (implementStrongReminderListComRespDto != null) {
                ImplementDataAppointFormatShiftTextComReqDto implementDataAppointFormatShiftTextComReqDto = new ImplementDataAppointFormatShiftTextComReqDto();
                implementDataAppointFormatShiftTextComReqDto.setCustomField1("#");//CUSTOM_CONVENTION//sourceId:1412758_1_56362
                if (implementStrongReminderListComRespDto != null && implementStrongReminderListComRespDto.getMessageList() != null && !CollectionUtil.isEmpty(implementStrongReminderListComRespDto.getMessageList())) {
                    implementDataAppointFormatShiftTextComReqDto.setDataAppointFormatShiftTextList(implementStrongReminderListComRespDto.getMessageList().stream().map(item -> item.getMessageContent())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:1401811_1_56362
                }

                /*D2执行强提醒内容列表转单字段[7515]   */
                Assert.isNull(implementDataAppointFormatShiftTextComReqDto.getCustomField1(), "D3执行智能指令沟通服务(公共)-D2执行强提醒内容列表转单字段-自定义字段1不能为空", false);
                implementDataAppointFormatShiftTextComRespDto = interfaceModeService.implementDataAppointFormatShiftTextCom(implementDataAppointFormatShiftTextComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
            if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
                queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("FORCING_ REMINDER_ COPY_ITEM");//CUSTOM_CONVENTION//sourceId:1401807_1_56361
                queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1401808_1_56361
                if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                    queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1401806_1_56361
                }

                /*D2-3查强提醒基础文案[2486]   */
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(), "D3执行智能指令沟通服务(公共)-D2-3查强提醒基础文案-开通对象ID不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D3执行智能指令沟通服务(公共)-D2-3查强提醒基础文案-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D3执行智能指令沟通服务(公共)-D2-3查强提醒基础文案-是否标准答案不能为空", false);
                queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            ImplementRoboticSceneSemanticEngineComRespDto implementRoboticSceneSemanticEngineComRespDto_2 = null;
            if (queryConfItemMatchAnswerDetailComRespDto != null && implementDataAppointFormatShiftTextComRespDto != null) {
                ImplementRoboticSceneSemanticEngineComReqDto implementRoboticSceneSemanticEngineComReqDto_1 = new ImplementRoboticSceneSemanticEngineComReqDto();
                implementRoboticSceneSemanticEngineComReqDto_1.setTemplateSemanticEngineCode("ASSEMBLY_STRONG_REMINDER_QUS_CONT_TEMP");//CUSTOM_CONVENTION//sourceId:1401776_1_56360
                if (queryConfItemMatchAnswerDetailComRespDto != null) {
                    implementRoboticSceneSemanticEngineComReqDto_1.setStrongReminderBasicCopy(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:1401779_1_56360
                }
                if (implementDataAppointFormatShiftTextComRespDto != null) {
                    implementRoboticSceneSemanticEngineComReqDto_1.setStrongReminderContent(implementDataAppointFormatShiftTextComRespDto.getCustomText());//SimpleFieldAssign//sourceId:1401780_1_56360
                }

                /*D2组织强提醒提问内容[8112]   */
                Assert.isNull(implementRoboticSceneSemanticEngineComReqDto_1.getTemplateSemanticEngineCode(), "D3执行智能指令沟通服务(公共)-D2组织强提醒提问内容-模板引擎标识不能为空", false);
                Assert.isNull(implementRoboticSceneSemanticEngineComReqDto_1.getStrongReminderBasicCopy(), "D3执行智能指令沟通服务(公共)-D2组织强提醒提问内容-强提醒部分内容不能为空", false);
                Assert.isNull(implementRoboticSceneSemanticEngineComReqDto_1.getStrongReminderContent(), "D3执行智能指令沟通服务(公共)-D2组织强提醒提问内容-强提醒核心内容不能为空", false);
                implementRoboticSceneSemanticEngineComRespDto_2 = fwCompTemplateEngineClient.implementRoboticSceneSemanticEngineCom(implementRoboticSceneSemanticEngineComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;
                Assert.isTrue(implementRoboticSceneSemanticEngineComRespDto_2 == null || implementRoboticSceneSemanticEngineComRespDto_2.getObjectName() == null, "找不到数据，系统异常", false);


            }
            ImplementMutDataToOneDatasComRespDto implementMutDataToOneDatasComRespDto_2 = null;
            if (implementRoboticSceneSemanticEngineComRespDto_2 != null) {
                ImplementMutDataToOneDatasComReqDto implementMutDataToOneDatasComReqDto_1 = new ImplementMutDataToOneDatasComReqDto();
                if (implementRoboticSceneSemanticEngineComRespDto_2 != null) {
                    implementMutDataToOneDatasComReqDto_1.setCustomField(implementRoboticSceneSemanticEngineComRespDto_2.getObjectName());//SimpleFieldAssign//sourceId:1400663_1_56365
                }

                /*D2执行输入消息内容单字段转数据集[5864]   */
                Assert.isNull(implementMutDataToOneDatasComReqDto_1.getCustomField(), "D3执行智能指令沟通服务(公共)-D2执行输入消息内容单字段转数据集-自定义字段不能为空", false);
                implementMutDataToOneDatasComRespDto_2 = interfaceModeService.implementMutDataToOneDatasCom(implementMutDataToOneDatasComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            ImplementGuidedThirdPartyIntelligentQaComRespDto implementGuidedThirdPartyIntelligentQaComRespDto_2 = null;
            if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null && implementMutDataToOneDatasComRespDto_2 != null) {
                ImplementGuidedThirdPartyIntelligentQaComReqDto implementGuidedThirdPartyIntelligentQaComReqDto_1 = new ImplementGuidedThirdPartyIntelligentQaComReqDto();
                implementGuidedThirdPartyIntelligentQaComReqDto_1.setBusModelVersion("PLUS_VERSION");//sourceId:2036980_1_56364
                if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                    implementGuidedThirdPartyIntelligentQaComReqDto_1.setResultAspObjId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1400587_1_56364
                }
                if (implementMutDataToOneDatasComRespDto_2 != null) {
                    //simpleList-to-objLists
                    for (String item : implementMutDataToOneDatasComRespDto_2.getComDatasList()) {
                        GetListIntelligentAnswersDto oneItem = new GetListIntelligentAnswersDto();
                        oneItem.setRole("user");//sourceId:282040_2_56364
                        if (implementMutDataToOneDatasComRespDto_2 != null) {
                            oneItem.setContent(item);//SimpleFieldAssign//sourceId:282039_2_56364
                        }

                        implementGuidedThirdPartyIntelligentQaComReqDto_1.getGetListIntelligentAnswersList().add(oneItem);
                    }//sourceId:1400588_1_56364
                }

                /*D2执行导向第三方智能问答(公共)[8103]   */
                Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto_1.getResultAspObjId(), "D3执行智能指令沟通服务(公共)-D2执行导向第三方智能问答(公共)-开通对象ID不能为空", false);
                Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto_1.getBusModelVersion(), "D3执行智能指令沟通服务(公共)-D2执行导向第三方智能问答(公共)-业务模型版本不能为空", false);
                implementGuidedThirdPartyIntelligentQaComRespDto_2 = fwCompIntelligentCommunicationClient.implementGuidedThirdPartyIntelligentQaCom(implementGuidedThirdPartyIntelligentQaComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;
                Assert.isTrue(implementGuidedThirdPartyIntelligentQaComRespDto_2 == null || implementGuidedThirdPartyIntelligentQaComRespDto_2.getContent() == null || implementGuidedThirdPartyIntelligentQaComRespDto_2 == null || implementGuidedThirdPartyIntelligentQaComRespDto_2.getRole() == null, "找不到数据，系统异常", false);


            }
            ImplementMarkdownTurnToTextComRespDto implementMarkdownTurnToTextComRespDto = null;
            if (implementGuidedThirdPartyIntelligentQaComRespDto_2 != null) {
                ImplementMarkdownTurnToTextComReqDto implementMarkdownTurnToTextComReqDto = new ImplementMarkdownTurnToTextComReqDto();
                if (implementGuidedThirdPartyIntelligentQaComRespDto_2 != null) {
                    implementMarkdownTurnToTextComReqDto.setMarkdownContent(implementGuidedThirdPartyIntelligentQaComRespDto_2.getContent());//SimpleFieldAssign//sourceId:1479353_1_59283
                }

                /*D2-执行markdown转文本(公共)[7517]   */
                Assert.isNull(implementMarkdownTurnToTextComReqDto.getMarkdownContent(), "D3执行智能指令沟通服务(公共)-D2-执行markdown转文本(公共)-markdown文本内容不能为空", false);
                implementMarkdownTurnToTextComRespDto = interfaceModeService.implementMarkdownTurnToTextCom(implementMarkdownTurnToTextComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
//ModelCode: receptionService
            ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_2 = null;
            if (implementMarkdownTurnToTextComRespDto != null) {
                ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_1 = new ImplementAcceptFieldByStandardDataReqDto();
                if (implementMarkdownTurnToTextComRespDto != null) {
                    receptionServiceReq_1.setContent(implementMarkdownTurnToTextComRespDto.getCustomText());//SimpleFieldAssign//sourceId:1404342_1_56435
                }

                /*M3-接收回答[7478]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getContent(), "D3执行智能指令沟通服务(公共)-M3-接收回答-消息内容不能为空", false);
                receptionServiceRes_2 = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq_1);


                receptionServiceRes_3 = receptionServiceRes_2;
            }
        } else if ((implementManuallyParsingInstructionParametersComRespDto != null && implementManuallyParsingInstructionParametersComRespDto.getCustomField() != null && implementManuallyParsingInstructionParametersComRespDto.getCustomField().equals("QUESTION_ANSWER"))) {
            //elseif(D2执行人工解析指令参数(公共).自定义字段 等于 想问答)  56349

            ImplementWantAskAnswerComRespDto implementWantAskAnswerComRespDto = null;
            if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                ImplementWantAskAnswerComReqDto implementWantAskAnswerComReqDto = new ImplementWantAskAnswerComReqDto();
                implementWantAskAnswerComReqDto.setMsgChannelClassCode("INTELLIGENT_STUDY");//sourceId:1477059_1_56424
                implementWantAskAnswerComReqDto.setChannelTypeCode("THIRD_QA_SESSION");//sourceId:1403989_1_56424
                implementWantAskAnswerComReqDto.setTableTypeCode("INTELLIGENT_HARDWARE_EQUIPMENT");//sourceId:1403990_1_56424
                if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                    implementWantAskAnswerComReqDto.setOriginalRoleMemberId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403995_1_56424
                    implementWantAskAnswerComReqDto.setUserId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403993_1_56424
                    implementWantAskAnswerComReqDto.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1403992_1_56424
                    implementWantAskAnswerComReqDto.setAppId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getAppId());//SimpleFieldAssign//sourceId:1403994_1_56424
                }
                if (reqDto != null) {
                    implementWantAskAnswerComReqDto.setContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1403988_1_56424
                    implementWantAskAnswerComReqDto.setEntityId(reqDto.getSn());//SimpleFieldAssign//sourceId:1403991_1_56424
                }

                /*D3执行想问答(公共)[8125]   */
                Assert.isNull(implementWantAskAnswerComReqDto.getOriginalRoleMemberId(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-身份人员ID不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto.getUserId(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-个人账号ID不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto.getContent(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-消息内容不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto.getMsgChannelClassCode(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-消息使用通道类别不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto.getChannelTypeCode(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-通道类型编码不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto.getTableTypeCode(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-归属主体内容类型编码不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto.getEntityId(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-归属主体内容ID不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto.getSpaceId(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-创建于空间ID不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto.getAppId(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-创建于联盟应用ID不能为空", false);
                implementWantAskAnswerComRespDto = implementWantAskAnswerCom(implementWantAskAnswerComReqDto)/*vcase invoke 同服务,同domain*/;


            }
            ImplementMarkdownTurnToTextComRespDto implementMarkdownTurnToTextComRespDto_2 = null;
            if (implementWantAskAnswerComRespDto != null) {
                ImplementMarkdownTurnToTextComReqDto implementMarkdownTurnToTextComReqDto_1 = new ImplementMarkdownTurnToTextComReqDto();
                if (implementWantAskAnswerComRespDto != null) {
                    implementMarkdownTurnToTextComReqDto_1.setMarkdownContent(implementWantAskAnswerComRespDto.getContent());//SimpleFieldAssign//sourceId:1479353_1_59284
                }

                /*D2-执行markdown转文本(公共)[7517]   */
                Assert.isNull(implementMarkdownTurnToTextComReqDto_1.getMarkdownContent(), "D3执行智能指令沟通服务(公共)-D2-执行markdown转文本(公共)-markdown文本内容不能为空", false);
                implementMarkdownTurnToTextComRespDto_2 = interfaceModeService.implementMarkdownTurnToTextCom(implementMarkdownTurnToTextComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            }
//ModelCode: receptionService
            ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_4 = null;
            if (implementMarkdownTurnToTextComRespDto_2 != null) {
                ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_2 = new ImplementAcceptFieldByStandardDataReqDto();
                if (implementMarkdownTurnToTextComRespDto_2 != null) {
                    receptionServiceReq_2.setContent(implementMarkdownTurnToTextComRespDto_2.getCustomText());//SimpleFieldAssign//sourceId:1404342_1_56434
                }

                /*M3-接收回答[7478]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_2.getContent(), "D3执行智能指令沟通服务(公共)-M3-接收回答-消息内容不能为空", false);
                receptionServiceRes_4 = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq_2);


                receptionServiceRes_3 = receptionServiceRes_4;
            }
        } else if ((implementManuallyParsingInstructionParametersComRespDto != null && implementManuallyParsingInstructionParametersComRespDto.getCustomField() != null && implementManuallyParsingInstructionParametersComRespDto.getCustomField().equals("INTELLIGENT_SERVICE"))) {
            //elseif(D2执行人工解析指令参数(公共).自定义字段 等于 智能服务专业工作)  56350

            ImplementWantAskAnswerComRespDto implementWantAskAnswerComRespDto_2 = null;
            if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                ImplementWantAskAnswerComReqDto implementWantAskAnswerComReqDto_1 = new ImplementWantAskAnswerComReqDto();
                implementWantAskAnswerComReqDto_1.setMsgChannelClassCode("INTELLIGENT_STUDY");//sourceId:1477059_1_56428
                implementWantAskAnswerComReqDto_1.setChannelTypeCode("THIRD_QA_SESSION");//sourceId:1403989_1_56428
                implementWantAskAnswerComReqDto_1.setTableTypeCode("INTELLIGENT_HARDWARE_EQUIPMENT");//sourceId:1403990_1_56428
                if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                    implementWantAskAnswerComReqDto_1.setOriginalRoleMemberId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403995_1_56428
                    implementWantAskAnswerComReqDto_1.setUserId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403993_1_56428
                    implementWantAskAnswerComReqDto_1.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1403992_1_56428
                    implementWantAskAnswerComReqDto_1.setAppId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getAppId());//SimpleFieldAssign//sourceId:1403994_1_56428
                }
                if (reqDto != null) {
                    implementWantAskAnswerComReqDto_1.setContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1403988_1_56428
                    implementWantAskAnswerComReqDto_1.setEntityId(reqDto.getSn());//SimpleFieldAssign//sourceId:1403991_1_56428
                }

                /*D3执行想问答(公共)[8125]   */
                Assert.isNull(implementWantAskAnswerComReqDto_1.getOriginalRoleMemberId(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-身份人员ID不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto_1.getUserId(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-个人账号ID不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto_1.getContent(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-消息内容不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto_1.getMsgChannelClassCode(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-消息使用通道类别不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto_1.getChannelTypeCode(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-通道类型编码不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto_1.getTableTypeCode(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-归属主体内容类型编码不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto_1.getEntityId(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-归属主体内容ID不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto_1.getSpaceId(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-创建于空间ID不能为空", false);
                Assert.isNull(implementWantAskAnswerComReqDto_1.getAppId(), "D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-创建于联盟应用ID不能为空", false);
                implementWantAskAnswerComRespDto_2 = implementWantAskAnswerCom(implementWantAskAnswerComReqDto_1)/*vcase invoke 同服务,同domain*/;


            }
            ImplementMarkdownTurnToTextComRespDto implementMarkdownTurnToTextComRespDto_3 = null;
            if (implementWantAskAnswerComRespDto_2 != null) {
                ImplementMarkdownTurnToTextComReqDto implementMarkdownTurnToTextComReqDto_2 = new ImplementMarkdownTurnToTextComReqDto();
                if (implementWantAskAnswerComRespDto_2 != null) {
                    implementMarkdownTurnToTextComReqDto_2.setMarkdownContent(implementWantAskAnswerComRespDto_2.getContent());//SimpleFieldAssign//sourceId:1479353_1_59285
                }

                /*D2-执行markdown转文本(公共)[7517]   */
                Assert.isNull(implementMarkdownTurnToTextComReqDto_2.getMarkdownContent(), "D3执行智能指令沟通服务(公共)-D2-执行markdown转文本(公共)-markdown文本内容不能为空", false);
                implementMarkdownTurnToTextComRespDto_3 = interfaceModeService.implementMarkdownTurnToTextCom(implementMarkdownTurnToTextComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


            }
//ModelCode: receptionService
            ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_5 = null;
            if (implementMarkdownTurnToTextComRespDto_3 != null) {
                ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_3 = new ImplementAcceptFieldByStandardDataReqDto();
                if (implementMarkdownTurnToTextComRespDto_3 != null) {
                    receptionServiceReq_3.setContent(implementMarkdownTurnToTextComRespDto_3.getCustomText());//SimpleFieldAssign//sourceId:1404342_1_56433
                }

                /*M3-接收回答[7478]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_3.getContent(), "D3执行智能指令沟通服务(公共)-M3-接收回答-消息内容不能为空", false);
                receptionServiceRes_5 = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq_3);


                receptionServiceRes_3 = receptionServiceRes_5;
            }
        } else if ((implementManuallyParsingInstructionParametersComRespDto != null && implementManuallyParsingInstructionParametersComRespDto.getCustomField() != null && implementManuallyParsingInstructionParametersComRespDto.getCustomField().equals("RAISE_QUESTION"))) {
            //elseif(D2执行人工解析指令参数(公共).自定义字段 等于 提出问题)  56351

            QueryUserInfoDetailComRespDto queryUserInfoDetailComRespDto = null;
            if (implementManuallyParsingInstructionParametersComRespDto != null) {
                QueryUserInfoDetailComReqDto queryUserInfoDetailComReqDto = new QueryUserInfoDetailComReqDto();
                if (implementManuallyParsingInstructionParametersComRespDto != null) {
                    queryUserInfoDetailComReqDto.setIdCardName(implementManuallyParsingInstructionParametersComRespDto.getCustomField3());//SimpleFieldAssign//sourceId:1403640_1_56388
                }

                /*D1-2查询任务问题负责人[408]   */
                Assert.isNull(queryUserInfoDetailComReqDto.getIdCardName(), "D3执行智能指令沟通服务(公共)-D1-2查询任务问题负责人-真实姓名不能为空", false);
                queryUserInfoDetailComRespDto = fwBaseUserClient.queryUserInfoDetailCom(queryUserInfoDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((queryUserInfoDetailComRespDto != null && queryUserInfoDetailComRespDto.getUserId() == null)) {
                //if(D1-2查询问题负责人个人账号（用于查询就职记录及接收部门ID）.账号 值等于空 )  59119

//异常结束 59120
                throw new BizException("C00278", "没有找到问题负责人，请提出问题注意负责人的真实姓名～", false);
            }
            QueryInductionDeptDetailComRespDto queryInductionDeptDetailComRespDto_2 = null;
            if (queryUserInfoDetailComRespDto != null && implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                QueryInductionDeptDetailComReqDto queryInductionDeptDetailComReqDto_1 = new QueryInductionDeptDetailComReqDto();
                queryInductionDeptDetailComReqDto_1.setInductionUnitTypeCode("DEPT");//sourceId:1403614_1_56391
                queryInductionDeptDetailComReqDto_1.setIsMainInduction("TRUE");//sourceId:1402946_1_56391
                queryInductionDeptDetailComReqDto_1.setIsTransaction("FALSE");//sourceId:1402947_1_56391
                queryInductionDeptDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1402948_1_56391
                if (queryUserInfoDetailComRespDto != null) {
                    queryInductionDeptDetailComReqDto_1.setUserId(queryUserInfoDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403654_1_56391
                }
                if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                    queryInductionDeptDetailComReqDto_1.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1402929_1_56391
                }

                /*D1查询就职的部门详情(公共)[7829]   */
                Assert.isNull(queryInductionDeptDetailComReqDto_1.getUserId(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-个人账号ID不能为空", false);
                Assert.isNull(queryInductionDeptDetailComReqDto_1.getInductionUnitTypeCode(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-就职单位类型实例不能为空", false);
                Assert.isNull(queryInductionDeptDetailComReqDto_1.getIsMainInduction(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-是否主岗不能为空", false);
                Assert.isNull(queryInductionDeptDetailComReqDto_1.getIsTransaction(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-是否异动不能为空", false);
                Assert.isNull(queryInductionDeptDetailComReqDto_1.getSubjectLifeCycle(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-主体生命周期不能为空", false);
                Assert.isNull(queryInductionDeptDetailComReqDto_1.getSpaceId(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-创建于空间ID不能为空", false);
                queryInductionDeptDetailComRespDto_2 = inductionRecordService.queryInductionDeptDetailCom(queryInductionDeptDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            AddQuestionBusinessProcessingComRespDto addQuestionBusinessProcessingComRespDto = null;
            if (implementManuallyParsingInstructionParametersComRespDto != null && queryInductionDeptDetailComRespDto != null && queryInductionDeptDetailComRespDto_2 != null) {
                AddQuestionBusinessProcessingComReqDto addQuestionBusinessProcessingComReqDto = new AddQuestionBusinessProcessingComReqDto();
                addQuestionBusinessProcessingComReqDto.setArrangeSubjectTypeCode("OMS_ORG_DEPT");//sourceId:1402984_1_56378
                addQuestionBusinessProcessingComReqDto.setCoordObjectTypeCode("OMS_ORG_DEPT");//sourceId:1402985_1_56378
                addQuestionBusinessProcessingComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1402993_1_56378
                if (implementManuallyParsingInstructionParametersComRespDto != null) {
                    addQuestionBusinessProcessingComReqDto.setQuestionIntroduce(implementManuallyParsingInstructionParametersComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1402979_1_56378
                    addQuestionBusinessProcessingComReqDto.setQuestionDesc(implementManuallyParsingInstructionParametersComRespDto.getCustomField5());//SimpleFieldAssign//sourceId:1402980_1_56378
                    addQuestionBusinessProcessingComReqDto.setQuestionLevel(implementManuallyParsingInstructionParametersComRespDto.getCustomField4());//SimpleFieldAssign//sourceId:1402981_1_56378
                }
                if (queryInductionDeptDetailComRespDto != null) {
                    addQuestionBusinessProcessingComReqDto.setArrangeSubjectId(queryInductionDeptDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1402983_1_56378
                    addQuestionBusinessProcessingComReqDto.setCoordObjectId(queryInductionDeptDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1402986_1_56378
                    addQuestionBusinessProcessingComReqDto.setCreateInductionId(queryInductionDeptDetailComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:1403631_1_56378
                }
                if (queryInductionDeptDetailComRespDto_2 != null) {
                    addQuestionBusinessProcessingComReqDto.setPrincipalInductionId(queryInductionDeptDetailComRespDto_2.getInductionRecordId());//SimpleFieldAssign//sourceId:1402996_1_56378
                }

                /*D3新增问题业务处理(公共)[7854]   */
                Assert.isNull(addQuestionBusinessProcessingComReqDto.getQuestionIntroduce(), "D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-问题文字简介不能为空", false);
                Assert.isNull(addQuestionBusinessProcessingComReqDto.getQuestionDesc(), "D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-问题文字描述不能为空", false);
                Assert.isNull(addQuestionBusinessProcessingComReqDto.getQuestionLevel(), "D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-问题等级不能为空", false);
                Assert.isNull(addQuestionBusinessProcessingComReqDto.getArrangeSubjectId(), "D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-安排主体ID不能为空", false);
                Assert.isNull(addQuestionBusinessProcessingComReqDto.getArrangeSubjectTypeCode(), "D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-安排主体类型编码不能为空", false);
                Assert.isNull(addQuestionBusinessProcessingComReqDto.getCoordObjectTypeCode(), "D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-归属对象类型编码不能为空", false);
                Assert.isNull(addQuestionBusinessProcessingComReqDto.getCoordObjectId(), "D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-归属对象ID不能为空", false);
                Assert.isNull(addQuestionBusinessProcessingComReqDto.getCreateInductionId(), "D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-创建人就职记录ID不能为空", false);
                Assert.isNull(addQuestionBusinessProcessingComReqDto.getPrincipalInductionId(), "D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-负责人就职记录ID不能为空", false);
                Assert.isNull(addQuestionBusinessProcessingComReqDto.getSubjectLifeCycle(), "D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-主体生命周期不能为空", false);
                addQuestionBusinessProcessingComRespDto = questionService.addQuestionBusinessProcessingCom(addQuestionBusinessProcessingComReqDto)/*vcase invoke isSameApp*/;
                Assert.isTrue(addQuestionBusinessProcessingComRespDto == null || addQuestionBusinessProcessingComRespDto.getQuestionId() == null, "找不到数据，系统异常", false);


            }
//ModelCode: receptionService
            ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_6 = null;
            ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_4 = new ImplementAcceptFieldByStandardDataReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_4.setContent(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1404342_1_56432
            }

            /*M3-接收回答[7478]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_4.getContent(), "D3执行智能指令沟通服务(公共)-M3-接收回答-消息内容不能为空", false);
            receptionServiceRes_6 = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq_4);


            receptionServiceRes_3 = receptionServiceRes_6;
        } else if ((implementManuallyParsingInstructionParametersComRespDto != null && implementManuallyParsingInstructionParametersComRespDto.getCustomField() != null && implementManuallyParsingInstructionParametersComRespDto.getCustomField().equals("ASSIGN_TASK"))) {
            //elseif(D2执行人工解析指令参数(公共).自定义字段 等于 安排任务)  56352

            QueryUserInfoDetailComRespDto queryUserInfoDetailComRespDto_2 = null;
            if (implementManuallyParsingInstructionParametersComRespDto != null) {
                QueryUserInfoDetailComReqDto queryUserInfoDetailComReqDto_1 = new QueryUserInfoDetailComReqDto();
                if (implementManuallyParsingInstructionParametersComRespDto != null) {
                    queryUserInfoDetailComReqDto_1.setIdCardName(implementManuallyParsingInstructionParametersComRespDto.getCustomField3());//SimpleFieldAssign//sourceId:1403640_1_56389
                }

                /*D1-2查询任务问题负责人[408]   */
                Assert.isNull(queryUserInfoDetailComReqDto_1.getIdCardName(), "D3执行智能指令沟通服务(公共)-D1-2查询任务问题负责人-真实姓名不能为空", false);
                queryUserInfoDetailComRespDto_2 = fwBaseUserClient.queryUserInfoDetailCom(queryUserInfoDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((queryUserInfoDetailComRespDto_2 != null && queryUserInfoDetailComRespDto_2.getUserId() == null)) {
                //if(D1-2查询任务负责人（用于查询就职记录及接收部门ID）.账号 值等于空 )  59117

//异常结束 59118
                throw new BizException("C00277", "没有找到任务负责人，请重新安排时候注意负责人的真实姓名～", false);
            }
            QueryInductionDeptDetailComRespDto queryInductionDeptDetailComRespDto_3 = null;
            if (queryUserInfoDetailComRespDto_2 != null && implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                QueryInductionDeptDetailComReqDto queryInductionDeptDetailComReqDto_2 = new QueryInductionDeptDetailComReqDto();
                queryInductionDeptDetailComReqDto_2.setInductionUnitTypeCode("DEPT");//sourceId:1403614_1_56390
                queryInductionDeptDetailComReqDto_2.setIsMainInduction("TRUE");//sourceId:1402946_1_56390
                queryInductionDeptDetailComReqDto_2.setIsTransaction("FALSE");//sourceId:1402947_1_56390
                queryInductionDeptDetailComReqDto_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1402948_1_56390
                if (queryUserInfoDetailComRespDto_2 != null) {
                    queryInductionDeptDetailComReqDto_2.setUserId(queryUserInfoDetailComRespDto_2.getUserId());//SimpleFieldAssign//sourceId:1403654_1_56390
                }
                if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                    queryInductionDeptDetailComReqDto_2.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1402929_1_56390
                }

                /*D1查询就职的部门详情(公共)[7829]   */
                Assert.isNull(queryInductionDeptDetailComReqDto_2.getUserId(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-个人账号ID不能为空", false);
                Assert.isNull(queryInductionDeptDetailComReqDto_2.getInductionUnitTypeCode(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-就职单位类型实例不能为空", false);
                Assert.isNull(queryInductionDeptDetailComReqDto_2.getIsMainInduction(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-是否主岗不能为空", false);
                Assert.isNull(queryInductionDeptDetailComReqDto_2.getIsTransaction(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-是否异动不能为空", false);
                Assert.isNull(queryInductionDeptDetailComReqDto_2.getSubjectLifeCycle(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-主体生命周期不能为空", false);
                Assert.isNull(queryInductionDeptDetailComReqDto_2.getSpaceId(), "D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-创建于空间ID不能为空", false);
                queryInductionDeptDetailComRespDto_3 = inductionRecordService.queryInductionDeptDetailCom(queryInductionDeptDetailComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            AddIndependentTaskBusinessProcessingComRespDto addIndependentTaskBusinessProcessingComRespDto = null;
            if (implementManuallyParsingInstructionParametersComRespDto != null && queryInductionDeptDetailComRespDto != null && queryInductionDeptDetailComRespDto_3 != null) {
                AddIndependentTaskBusinessProcessingComReqDto addIndependentTaskBusinessProcessingComReqDto = new AddIndependentTaskBusinessProcessingComReqDto();
                addIndependentTaskBusinessProcessingComReqDto.setTaskType("ROUTINE_TASK");//sourceId:1403586_1_56384
                addIndependentTaskBusinessProcessingComReqDto.setWorkTaskType("INDEPENDENT_TASK");//sourceId:1403613_1_56384
                addIndependentTaskBusinessProcessingComReqDto.setArrangeSubjectTypeCode("OMS_ORG_DEPT");//sourceId:1403588_1_56384
                addIndependentTaskBusinessProcessingComReqDto.setCoordObjectTypeCode("OMS_ORG_DEPT");//sourceId:1403596_1_56384
                addIndependentTaskBusinessProcessingComReqDto.setPlanStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403598_1_56384
                addIndependentTaskBusinessProcessingComReqDto.setSourceTypeCode("CONVENTIONAL_WORK_TASKS");//CUSTOM_CONVENTION//sourceId:1403600_1_56384
                addIndependentTaskBusinessProcessingComReqDto.setIsSystemTask("FALSE");//sourceId:1403607_1_56384
                addIndependentTaskBusinessProcessingComReqDto.setIsSystemComplete("FALSE");//sourceId:1403608_1_56384
                addIndependentTaskBusinessProcessingComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1403602_1_56384
                addIndependentTaskBusinessProcessingComReqDto.setMessageImportantLevel(Long.valueOf(4));//CUSTOM_CONVENTION//sourceId:1403609_1_56384
                if (implementManuallyParsingInstructionParametersComRespDto != null) {
                    addIndependentTaskBusinessProcessingComReqDto.setTaskName(implementManuallyParsingInstructionParametersComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1403584_1_56384
                    addIndependentTaskBusinessProcessingComReqDto.setTaskDesc(implementManuallyParsingInstructionParametersComRespDto.getCustomField5());//SimpleFieldAssign//sourceId:1403603_1_56384
                    addIndependentTaskBusinessProcessingComReqDto.setPlanEndTime(implementManuallyParsingInstructionParametersComRespDto.getCustomField4() != null ? CommonFunctionHelper.str2Date(implementManuallyParsingInstructionParametersComRespDto.getCustomField4()) : null);//SimpleFieldAssign//sourceId:1403599_1_56384
                }
                if (queryInductionDeptDetailComRespDto != null) {
                    addIndependentTaskBusinessProcessingComReqDto.setArrangeSubjectId(queryInductionDeptDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1403587_1_56384
                    addIndependentTaskBusinessProcessingComReqDto.setCoordObjectId(queryInductionDeptDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1403597_1_56384
                    addIndependentTaskBusinessProcessingComReqDto.setReportObjectInductionRecordId(queryInductionDeptDetailComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:1403601_1_56384
                }
                if (queryInductionDeptDetailComRespDto_3 != null) {
                    addIndependentTaskBusinessProcessingComReqDto.setReceiveSubjectId(queryInductionDeptDetailComRespDto_3.getEntityId());//SimpleFieldAssign//sourceId:1403589_1_56384
                    addIndependentTaskBusinessProcessingComReqDto.setPrincipalInductionId(queryInductionDeptDetailComRespDto_3.getInductionRecordId());//SimpleFieldAssign//sourceId:1403605_1_56384
                }

                /*D3-新增独立任务（或子任务）业务处理(公共)[7853]   */
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getTaskName(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-任务名称不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getTaskDesc(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-任务简介不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getTaskType(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-任务类型不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getWorkTaskType(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-工作任务类别不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getArrangeSubjectId(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-安排主体ID不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getArrangeSubjectTypeCode(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-安排主体类型编码不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getCoordObjectTypeCode(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-归属对象类型编码不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getCoordObjectId(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-归属对象ID不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getPlanStartTime(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-计划开始时间不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getPlanEndTime(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-计划结束时间不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getSourceTypeCode(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-来源类型编码不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getReportObjectInductionRecordId(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-汇报对象就职记录ID不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getIsSystemTask(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-是否系统任务不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getIsSystemComplete(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-是否系统完成不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getSubjectLifeCycle(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-主体生命周期不能为空", false);
                Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getMessageImportantLevel(), "D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-消息重要紧急度层级不能为空", false);
                addIndependentTaskBusinessProcessingComRespDto = workTasksService.addIndependentTaskBusinessProcessingCom(addIndependentTaskBusinessProcessingComReqDto)/*vcase invoke isSameApp*/;


            }
//ModelCode: receptionService
            ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_7 = null;
            ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_5 = new ImplementAcceptFieldByStandardDataReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_5.setContent(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1404342_1_56431
            }

            /*M3-接收回答[7478]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_5.getContent(), "D3执行智能指令沟通服务(公共)-M3-接收回答-消息内容不能为空", false);
            receptionServiceRes_7 = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq_5);


            receptionServiceRes_3 = receptionServiceRes_7;
        } else if ((implementManuallyParsingInstructionParametersComRespDto != null && implementManuallyParsingInstructionParametersComRespDto.getCustomField() != null && implementManuallyParsingInstructionParametersComRespDto.getCustomField().equals("RECORD_IDEAS"))) {
            //elseif(D2执行人工解析指令参数(公共).自定义字段 等于 记录创意想法)  59268

            ImplementRecordIdeasComRespDto implementRecordIdeasComRespDto = null;
            if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null && queryInductionDeptDetailComRespDto != null) {
                ImplementRecordIdeasComReqDto implementRecordIdeasComReqDto = new ImplementRecordIdeasComReqDto();
                implementRecordIdeasComReqDto.setCustomField("1");//CUSTOM_CONVENTION//sourceId:1495348_1_59276
                if (reqDto != null) {
                    implementRecordIdeasComReqDto.setContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1479340_1_59276
                }
                if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                    implementRecordIdeasComReqDto.setOriginalRoleMemberId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1479336_1_59276
                    implementRecordIdeasComReqDto.setUserId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getUserId());//SimpleFieldAssign//sourceId:1479337_1_59276
                    implementRecordIdeasComReqDto.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1479338_1_59276
                    implementRecordIdeasComReqDto.setAppId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getAppId());//SimpleFieldAssign//sourceId:1479339_1_59276
                }
                if (queryInductionDeptDetailComRespDto != null) {
                    implementRecordIdeasComReqDto.setCreateInductionId(queryInductionDeptDetailComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:1479352_1_59276
                }

                /*D3执行记录创意想法(公共)[8289]   */
                Assert.isNull(implementRecordIdeasComReqDto.getCustomField(), "D3执行智能指令沟通服务(公共)-D3执行记录创意想法(公共)-自定义字段不能为空", false);
                Assert.isNull(implementRecordIdeasComReqDto.getContent(), "D3执行智能指令沟通服务(公共)-D3执行记录创意想法(公共)-消息内容不能为空", false);
                Assert.isNull(implementRecordIdeasComReqDto.getOriginalRoleMemberId(), "D3执行智能指令沟通服务(公共)-D3执行记录创意想法(公共)-身份人员ID不能为空", false);
                Assert.isNull(implementRecordIdeasComReqDto.getUserId(), "D3执行智能指令沟通服务(公共)-D3执行记录创意想法(公共)-账号ID不能为空", false);
                Assert.isNull(implementRecordIdeasComReqDto.getCreateInductionId(), "D3执行智能指令沟通服务(公共)-D3执行记录创意想法(公共)-创建人就职记录ID不能为空", false);
                Assert.isNull(implementRecordIdeasComReqDto.getSpaceId(), "D3执行智能指令沟通服务(公共)-D3执行记录创意想法(公共)-创建于空间ID不能为空", false);
                Assert.isNull(implementRecordIdeasComReqDto.getAppId(), "D3执行智能指令沟通服务(公共)-D3执行记录创意想法(公共)-创建于联盟应用ID不能为空", false);
                implementRecordIdeasComRespDto = implementRecordIdeasCom(implementRecordIdeasComReqDto)/*vcase invoke 同服务,同domain*/;


            }
//ModelCode: receptionService
            ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_8 = null;
            ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_6 = new ImplementAcceptFieldByStandardDataReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_6.setContent(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1404342_1_59277
            }

            /*M3-接收回答[7478]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_6.getContent(), "D3执行智能指令沟通服务(公共)-M3-接收回答-消息内容不能为空", false);
            receptionServiceRes_8 = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq_6);


            receptionServiceRes_3 = receptionServiceRes_8;
        } else if ((implementManuallyParsingInstructionParametersComRespDto != null && implementManuallyParsingInstructionParametersComRespDto.getCustomField() != null && implementManuallyParsingInstructionParametersComRespDto.getCustomField().equals("RECORD_MESSAGE"))) {
            //elseif(D2执行人工解析指令参数(公共).自定义字段 等于 记录重要笔记)  59990

            ImplementRecordIdeasComRespDto implementRecordIdeasComRespDto_1 = null;
            if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null && queryInductionDeptDetailComRespDto != null) {
                ImplementRecordIdeasComReqDto implementRecordIdeasComReqDto_1 = new ImplementRecordIdeasComReqDto();
                implementRecordIdeasComReqDto_1.setCustomField("2");//CUSTOM_CONVENTION//sourceId:1495355_1_59991
                if (reqDto != null) {
                    implementRecordIdeasComReqDto_1.setContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1495353_1_59991
                }
                if (implementDeviceAcquisitionOrgPersonalInfoComRespDto != null) {
                    implementRecordIdeasComReqDto_1.setOriginalRoleMemberId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1495349_1_59991
                    implementRecordIdeasComReqDto_1.setUserId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getUserId());//SimpleFieldAssign//sourceId:1495350_1_59991
                    implementRecordIdeasComReqDto_1.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1495351_1_59991
                    implementRecordIdeasComReqDto_1.setAppId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getAppId());//SimpleFieldAssign//sourceId:1495352_1_59991
                }
                if (queryInductionDeptDetailComRespDto != null) {
                    implementRecordIdeasComReqDto_1.setCreateInductionId(queryInductionDeptDetailComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:1495354_1_59991
                }

                /*D3执行记录重要笔记(公共)[8289]   */
                Assert.isNull(implementRecordIdeasComReqDto_1.getCustomField(), "D3执行智能指令沟通服务(公共)-D3执行记录重要笔记(公共)-自定义字段不能为空", false);
                Assert.isNull(implementRecordIdeasComReqDto_1.getContent(), "D3执行智能指令沟通服务(公共)-D3执行记录重要笔记(公共)-消息内容不能为空", false);
                Assert.isNull(implementRecordIdeasComReqDto_1.getOriginalRoleMemberId(), "D3执行智能指令沟通服务(公共)-D3执行记录重要笔记(公共)-身份人员ID不能为空", false);
                Assert.isNull(implementRecordIdeasComReqDto_1.getUserId(), "D3执行智能指令沟通服务(公共)-D3执行记录重要笔记(公共)-账号ID不能为空", false);
                Assert.isNull(implementRecordIdeasComReqDto_1.getCreateInductionId(), "D3执行智能指令沟通服务(公共)-D3执行记录重要笔记(公共)-创建人就职记录ID不能为空", false);
                Assert.isNull(implementRecordIdeasComReqDto_1.getSpaceId(), "D3执行智能指令沟通服务(公共)-D3执行记录重要笔记(公共)-创建于空间ID不能为空", false);
                Assert.isNull(implementRecordIdeasComReqDto_1.getAppId(), "D3执行智能指令沟通服务(公共)-D3执行记录重要笔记(公共)-创建于联盟应用ID不能为空", false);
                implementRecordIdeasComRespDto_1 = implementRecordIdeasCom(implementRecordIdeasComReqDto_1)/*vcase invoke 同服务,同domain*/;


            }
//ModelCode: receptionService
            ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_9 = null;
            ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_7 = new ImplementAcceptFieldByStandardDataReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_7.setContent(receptionServiceRes.getCustomField4());//SimpleFieldAssign//sourceId:1404342_1_59992
            }

            /*M3-接收回答[7478]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_7.getContent(), "D3执行智能指令沟通服务(公共)-M3-接收回答-消息内容不能为空", false);
            receptionServiceRes_9 = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq_7);


            receptionServiceRes_3 = receptionServiceRes_9;
        } else {
            //else  56355

//异常结束 56356
            throw new BizException("C00275", "无效指令，请您再重新说一下～", false);
        }
        ImplementIntelligentCommandCommunicationServicesComRespDto retData = new ImplementIntelligentCommandCommunicationServicesComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setContent(receptionServiceRes_3.getContent());//SimpleFieldAssign//sourceId:1404695_1
        }


        return retData;
    }

    /**
     * D3执行想问答(公共)[8125]
     * gen by moon at 12/13/2024, 11:13:14 PM
     */
    @Trace(operationName = "D3执行想问答(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementWantAskAnswerComRespDto implementWantAskAnswerCom(ImplementWantAskAnswerComReqDto reqDto) {


        ImplementGuidedThirdPartyIntelligentQaComRespDto implementGuidedThirdPartyIntelligentQaComRespDto_1 = null;
//virtualUsage D1-2查询发送方头像姓名  56393
        QueryUserInfoDetailComRespDto queryUserInfoDetailComRespDto = null;
        QueryUserInfoDetailComReqDto queryUserInfoDetailComReqDto = new QueryUserInfoDetailComReqDto();
        if (reqDto != null) {
            queryUserInfoDetailComReqDto.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1403699_1_56393
        }

        /*D1-2查询发送方头像姓名[408]   */
        Assert.isNull(queryUserInfoDetailComReqDto.getUserId(), "D3执行想问答(公共)-D1-2查询发送方头像姓名-账号不能为空", false);
        queryUserInfoDetailComRespDto = fwBaseUserClient.queryUserInfoDetailCom(queryUserInfoDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
        Assert.isTrue(queryUserInfoDetailComRespDto == null || queryUserInfoDetailComRespDto.getUserFace() == null || queryUserInfoDetailComRespDto == null || queryUserInfoDetailComRespDto.getIdCardName() == null, "找不到数据，系统异常", false);


        if ((queryUserInfoDetailComRespDto != null && queryUserInfoDetailComRespDto.getUserId() != null)) {
            //if(D1-2查询发送方头像姓名.账号 值不等于空 )  56394

            QueryAppDetailComRespDto queryAppDetailComRespDto = null;
            QueryAppDetailComReqDto queryAppDetailComReqDto = new QueryAppDetailComReqDto();
            if (reqDto != null) {
                queryAppDetailComReqDto.setUniqueSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403841_1_56397
            }

            /*D1-2查询小助手身份人员ID[3268]   */
            Assert.isNull(queryAppDetailComReqDto.getUniqueSpaceId(), "D3执行想问答(公共)-D1-2查询小助手身份人员ID-管理的空间ID不能为空", false);
            queryAppDetailComRespDto = baseService.queryAppDetailCom(queryAppDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
            Assert.isTrue(queryAppDetailComRespDto == null || queryAppDetailComRespDto.getSenderMemberId() == null, "找不到数据，系统异常", false);


            QueryMemberProfileDetailComRespDto queryMemberProfileDetailComRespDto = null;
            if (queryAppDetailComRespDto != null) {
                QueryMemberProfileDetailComReqDto queryMemberProfileDetailComReqDto = new QueryMemberProfileDetailComReqDto();
                if (queryAppDetailComRespDto != null) {
                    queryMemberProfileDetailComReqDto.setOriginalRoleMemberId(queryAppDetailComRespDto.getSenderMemberId());//SimpleFieldAssign//sourceId:1403853_1_56398
                    queryMemberProfileDetailComReqDto.setSpaceId(queryAppDetailComRespDto.getUniqueSpaceId());//SimpleFieldAssign//sourceId:1403854_1_56398
                }

                /*D1查询小助手个人账号及头像姓名[6778]   */
                Assert.isNull(queryMemberProfileDetailComReqDto.getOriginalRoleMemberId(), "D3执行想问答(公共)-D1查询小助手个人账号及头像姓名-身份人员ID不能为空", false);
                Assert.isNull(queryMemberProfileDetailComReqDto.getSpaceId(), "D3执行想问答(公共)-D1查询小助手个人账号及头像姓名-创建于空间ID不能为空", false);
                queryMemberProfileDetailComRespDto = fwBaseMemberClient.queryMemberProfileDetailCom(queryMemberProfileDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            QueryMeMessageVirtualImageDetailComRespDto queryMeMessageVirtualImageDetailComRespDto = null;
            if (queryMemberProfileDetailComRespDto != null) {
                QueryMeMessageVirtualImageDetailComReqDto queryMeMessageVirtualImageDetailComReqDto = new QueryMeMessageVirtualImageDetailComReqDto();
                queryMeMessageVirtualImageDetailComReqDto.setVirtualImageViewType("SELF_COGNITION");//sourceId:1479335_1_59233
                queryMeMessageVirtualImageDetailComReqDto.setSceneTypeCode("SYSTEM");//sourceId:1478637_1_59233
                queryMeMessageVirtualImageDetailComReqDto.setSceneSubTypeCode("STRONG_REMINDER_BY_ASSISTANT");//sourceId:1478643_1_59233
                if (queryMemberProfileDetailComRespDto != null) {
                    queryMeMessageVirtualImageDetailComReqDto.setOriginalRoleMemberId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1478636_1_59233
                }
                if (reqDto != null) {
                    queryMeMessageVirtualImageDetailComReqDto.setResultAspObjId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1478648_1_59233
                }

                /*D2查询我的消息提醒形象详情(公共)[6800]   */
                Assert.isNull(queryMeMessageVirtualImageDetailComReqDto.getOriginalRoleMemberId(), "D3执行想问答(公共)-D2查询我的消息提醒形象详情(公共)-身份人员ID不能为空", false);
                Assert.isNull(queryMeMessageVirtualImageDetailComReqDto.getVirtualImageViewType(), "D3执行想问答(公共)-D2查询我的消息提醒形象详情(公共)-虚拟形象展示用途类型不能为空", false);
                Assert.isNull(queryMeMessageVirtualImageDetailComReqDto.getSceneTypeCode(), "D3执行想问答(公共)-D2查询我的消息提醒形象详情(公共)-冗余使用大场景类型编码不能为空", false);
                Assert.isNull(queryMeMessageVirtualImageDetailComReqDto.getSceneSubTypeCode(), "D3执行想问答(公共)-D2查询我的消息提醒形象详情(公共)-冗余使用子场景类型编码不能为空", false);
                Assert.isNull(queryMeMessageVirtualImageDetailComReqDto.getResultAspObjId(), "D3执行想问答(公共)-D2查询我的消息提醒形象详情(公共)-开通对象ID不能为空", false);
                queryMeMessageVirtualImageDetailComRespDto = fwCompMessageClient.queryMeMessageVirtualImageDetailCom(queryMeMessageVirtualImageDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            QueryChannelDetailComRespDto queryChannelDetailComRespDto = null;
            QueryChannelDetailComReqDto queryChannelDetailComReqDto = new QueryChannelDetailComReqDto();
            if (reqDto != null) {
                queryChannelDetailComReqDto.setChannelTypeCode(reqDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403681_1_56404
                queryChannelDetailComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1403682_1_56404
                queryChannelDetailComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403691_1_56404
                queryChannelDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403683_1_56404
            }

            /*D2查询通道详情(公共)[7101]   */
            Assert.isNull(queryChannelDetailComReqDto.getChannelTypeCode(), "D3执行想问答(公共)-D2查询通道详情(公共)-通道类型编码不能为空", false);
            Assert.isNull(queryChannelDetailComReqDto.getEntityId(), "D3执行想问答(公共)-D2查询通道详情(公共)-归属主体内容ID不能为空", false);
            Assert.isNull(queryChannelDetailComReqDto.getTableTypeCode(), "D3执行想问答(公共)-D2查询通道详情(公共)-归属主体内容类型编码不能为空", false);
            Assert.isNull(queryChannelDetailComReqDto.getSpaceId(), "D3执行想问答(公共)-D2查询通道详情(公共)-创建于空间ID不能为空", false);
            queryChannelDetailComRespDto = fwCompMessageClient.queryChannelDetailCom(queryChannelDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            if ((queryChannelDetailComRespDto != null && queryChannelDetailComRespDto.getMessageChannelId() == null)) {
                //if(D2查询通道详情(公共).通道ID 值等于空 )  56405

                GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto = null;
                if (queryUserInfoDetailComRespDto != null) {
                    GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto = new GenerateSemanticInstanceStoryComReqDto();
                    generateSemanticInstanceStoryComReqDto.setTemplateSemanticEngineCode("TWO_PEOPLE_CHAT_DEFAULT_PROMPT_MESSAGE");//CUSTOM_CONVENTION//sourceId:1492482_1_59870
                    generateSemanticInstanceStoryComReqDto.setFirstFieldName("idCardName");//CUSTOM_CONVENTION//sourceId:1492476_1_59870
                    if (queryUserInfoDetailComRespDto != null) {
                        generateSemanticInstanceStoryComReqDto.setFirstFieldValue(queryUserInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1492477_1_59870
                    }

                    /*D2生成“我是**”[8234]   */
                    Assert.isNull(generateSemanticInstanceStoryComReqDto.getTemplateSemanticEngineCode(), "D3执行想问答(公共)-D2生成“我是**”-模板引擎标识不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldName(), "D3执行想问答(公共)-D2生成“我是**”-第一个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldValue(), "D3执行想问答(公共)-D2生成“我是**”-第一个字段字段值不能为空", false);
                    generateSemanticInstanceStoryComRespDto = fwCompTemplateEngineClient.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementMulitDataToOneDatasComRespDto implementMulitDataToOneDatasComRespDto = null;
                if (queryMemberProfileDetailComRespDto != null) {
                    ImplementMulitDataToOneDatasComReqDto implementMulitDataToOneDatasComReqDto = new ImplementMulitDataToOneDatasComReqDto();
                    if (queryMemberProfileDetailComRespDto != null) {
                        implementMulitDataToOneDatasComReqDto.setCustomField(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1492466_1_59869
                        implementMulitDataToOneDatasComReqDto.setCustomField1(queryMemberProfileDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1492467_1_59869
                    }

                    /*D2小助手身份人员ID转数据集(公共)[5869]   */
                    Assert.isNull(implementMulitDataToOneDatasComReqDto.getCustomField(), "D3执行想问答(公共)-D2小助手身份人员ID转数据集(公共)-第一条记录A字段不能为空", false);
                    Assert.isNull(implementMulitDataToOneDatasComReqDto.getCustomField1(), "D3执行想问答(公共)-D2小助手身份人员ID转数据集(公共)-第一条记录B字段不能为空", false);
                    implementMulitDataToOneDatasComRespDto = interfaceModeService.implementMulitDataToOneDatasCom(implementMulitDataToOneDatasComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementPullNPeopleBuildGroupComRespDto implementPullNPeopleBuildGroupComRespDto = null;
                if (implementMulitDataToOneDatasComRespDto != null && generateSemanticInstanceStoryComRespDto != null && queryMemberProfileDetailComRespDto != null && queryUserInfoDetailComRespDto != null) {
                    ImplementPullNPeopleBuildGroupComReqDto implementPullNPeopleBuildGroupComReqDto = new ImplementPullNPeopleBuildGroupComReqDto();
                    implementPullNPeopleBuildGroupComReqDto.setMessageLocationTypeCode("INTELLIGENT_STUDY");//CUSTOM_CONVENTION//sourceId:1492437_1_59868
                    implementPullNPeopleBuildGroupComReqDto.setMessageTemplateCode("CREATE_MULT_GROUP_DEFAULT_PROMPT_MESSAGE");//CUSTOM_CONVENTION//sourceId:1492438_1_59868
                    implementPullNPeopleBuildGroupComReqDto.setPlatformReplace("FALSE");//sourceId:1492447_1_59868
                    implementPullNPeopleBuildGroupComReqDto.setChannelName("我的智能问答");//CUSTOM_CONVENTION//sourceId:1492450_1_59868
                    implementPullNPeopleBuildGroupComReqDto.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1492445_1_59868
                    implementPullNPeopleBuildGroupComReqDto.setBorcScene("TOB_SCENE");//sourceId:1492436_1_59868
                    implementPullNPeopleBuildGroupComReqDto.setIsAssistant("FALSE");//sourceId:1492439_1_59868
                    implementPullNPeopleBuildGroupComReqDto.setMessageRole("user");//sourceId:1492440_1_59868
                    implementPullNPeopleBuildGroupComReqDto.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1492458_1_59868
                    if (implementMulitDataToOneDatasComRespDto != null && implementMulitDataToOneDatasComRespDto.getMulitDataToOneDatasList() != null && !CollectionUtil.isEmpty(implementMulitDataToOneDatasComRespDto.getMulitDataToOneDatasList())) {
                        implementPullNPeopleBuildGroupComReqDto.setMemberChannelList(//objList-to-objLists
                                implementMulitDataToOneDatasComRespDto.getMulitDataToOneDatasList().stream().map(item -> {
                                    com.wicket.okrcomponent.integration.dto.MemberChannelDto elm = new com.wicket.okrcomponent.integration.dto.MemberChannelDto();
                                    if (item != null) {
                                        elm.setOriginalRoleMemberId(item.getCustomField1());//SimpleFieldAssign//sourceId:293902_2_59868
                                        elm.setUserId(item.getCustomField2());//SimpleFieldAssign//sourceId:293903_2_59868
                                    }
                                    return elm;
                                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1492435_1_59868
                    }
                    if (reqDto != null) {
                        implementPullNPeopleBuildGroupComReqDto.setMsgChannelClassCode(reqDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1492465_1_59868
                        implementPullNPeopleBuildGroupComReqDto.setChannelTypeCode(reqDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1492457_1_59868
                        implementPullNPeopleBuildGroupComReqDto.setNewTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1492451_1_59868
                        implementPullNPeopleBuildGroupComReqDto.setNewEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1492452_1_59868
                        implementPullNPeopleBuildGroupComReqDto.setSenderOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1492441_1_59868
                        implementPullNPeopleBuildGroupComReqDto.setSenderUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1492442_1_59868
                        implementPullNPeopleBuildGroupComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1492448_1_59868
                        implementPullNPeopleBuildGroupComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1492449_1_59868
                    }
                    if (generateSemanticInstanceStoryComRespDto != null) {
                        implementPullNPeopleBuildGroupComReqDto.setMessageContent(generateSemanticInstanceStoryComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1492446_1_59868
                    }
                    if (queryMemberProfileDetailComRespDto != null) {
                        implementPullNPeopleBuildGroupComReqDto.setChannelLogo(queryMemberProfileDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1492453_1_59868
                    }
                    if (queryUserInfoDetailComRespDto != null) {
                        implementPullNPeopleBuildGroupComReqDto.setSenderProfilePictureAddress(queryUserInfoDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1492443_1_59868
                        implementPullNPeopleBuildGroupComReqDto.setNameOfSender(queryUserInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1492444_1_59868
                    }

                    /*D2执行拉N人建群(公共)[7031]   */
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getMessageLocationTypeCode(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-消息位置标识不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getMessageTemplateCode(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-消息模板标识不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getPlatformReplace(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-是否平台代操作不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getMsgChannelClassCode(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-消息使用通道类别不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getChannelTypeCode(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-通道类型编码不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getMessageContent(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-消息内容不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getChannelName(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-通道名称不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getChannelLogo(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-通道缩略图地址不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getNewTableTypeCode(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-通道归属主体内容类型编码不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getNewEntityId(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-通道归属主体内容ID不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getMessageImportantLevel(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-消息重要紧急度层级不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getBorcScene(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-toB或toC场景不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getIsAssistant(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-发送方是否助手不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getMessageRole(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-发送方角色不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getSenderOriginalRoleMemberId(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-发送方身份人员ID不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getSenderUserId(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-发送方账号ID不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getSenderProfilePictureAddress(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-发送方头像地址不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getNameOfSender(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-发送方姓名不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getOperateTime(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-操作时间不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getSpaceId(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-创建于空间ID不能为空", false);
                    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getAppId(), "D3执行想问答(公共)-D2执行拉N人建群(公共)-创建于联盟应用ID不能为空", false);
                    implementPullNPeopleBuildGroupComRespDto = fwCompMessageClient.implementPullNPeopleBuildGroupCom(implementPullNPeopleBuildGroupComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementGroupSendMessagesNpeopleComRespDto implementGroupSendMessagesNpeopleComRespDto = null;
                if (queryUserInfoDetailComRespDto != null && implementPullNPeopleBuildGroupComRespDto != null) {
                    ImplementGroupSendMessagesNpeopleComReqDto implementGroupSendMessagesNpeopleComReqDto = new ImplementGroupSendMessagesNpeopleComReqDto();
                    implementGroupSendMessagesNpeopleComReqDto.setBorcScene("TOB_SCENE");//sourceId:1403748_1_56407
                    implementGroupSendMessagesNpeopleComReqDto.setMessageLocationTypeCode("INTELLIGENT_STUDY");//CUSTOM_CONVENTION//sourceId:1403749_1_56407
                    implementGroupSendMessagesNpeopleComReqDto.setMessageTemplateCode("THIRD_QA_SESSION_MESSAGE_TEMPLATE");//CUSTOM_CONVENTION//sourceId:1403757_1_56407
                    implementGroupSendMessagesNpeopleComReqDto.setIsAssistant("FALSE");//sourceId:1403766_1_56407
                    implementGroupSendMessagesNpeopleComReqDto.setMessageRole("user");//sourceId:1403750_1_56407
                    implementGroupSendMessagesNpeopleComReqDto.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1403763_1_56407
                    implementGroupSendMessagesNpeopleComReqDto.setMessageTitle("我的问题");//CUSTOM_CONVENTION//sourceId:1403907_1_56407
                    implementGroupSendMessagesNpeopleComReqDto.setHandleType("NO_NEED_HANDLING");//sourceId:1443708_1_56407
                    implementGroupSendMessagesNpeopleComReqDto.setPlatformReplace("FALSE");//sourceId:1403760_1_56407
                    implementGroupSendMessagesNpeopleComReqDto.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403771_1_56407
                    implementGroupSendMessagesNpeopleComReqDto.setComNumField(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1403765_1_56407
                    if (reqDto != null) {
                        implementGroupSendMessagesNpeopleComReqDto.setSenderOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403906_1_56407
                        implementGroupSendMessagesNpeopleComReqDto.setSenderUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1403752_1_56407
                        implementGroupSendMessagesNpeopleComReqDto.setSurfaceCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403755_1_56407
                        implementGroupSendMessagesNpeopleComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1403756_1_56407
                        implementGroupSendMessagesNpeopleComReqDto.setMessageContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1403764_1_56407
                        implementGroupSendMessagesNpeopleComReqDto.setMsgChannelClassCode(reqDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1447844_1_56407
                        implementGroupSendMessagesNpeopleComReqDto.setChannelTypeCode(reqDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403770_1_56407
                        implementGroupSendMessagesNpeopleComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403761_1_56407
                        implementGroupSendMessagesNpeopleComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1403762_1_56407
                    }
                    if (queryUserInfoDetailComRespDto != null) {
                        implementGroupSendMessagesNpeopleComReqDto.setSenderProfilePictureAddress(queryUserInfoDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1403753_1_56407
                        implementGroupSendMessagesNpeopleComReqDto.setNameOfSender(queryUserInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1403754_1_56407
                    }
                    if (implementPullNPeopleBuildGroupComRespDto != null) {
                        implementGroupSendMessagesNpeopleComReqDto.setMessageChannelId(implementPullNPeopleBuildGroupComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403758_1_56407
                        implementGroupSendMessagesNpeopleComReqDto.setMemberChannelRelationId(implementPullNPeopleBuildGroupComRespDto.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1443709_1_56407
                    }

                    /*D2执行群里会话发消息N人(提问)[7028]   */
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getBorcScene(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-toB或toC场景不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMessageLocationTypeCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息位置标识不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMessageTemplateCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息模板标识不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getIsAssistant(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方是否助手不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMessageRole(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方角色不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getSenderOriginalRoleMemberId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方身份人员ID不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getSenderUserId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方账号ID不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getSenderProfilePictureAddress(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方头像地址不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getNameOfSender(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方姓名不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getSurfaceCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-归属内容类型编码不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getEntityId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-归属内容ID不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMessageImportantLevel(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息重要紧急度层级不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMessageTitle(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息标题不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMessageContent(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息内容不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMsgChannelClassCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息使用通道类别不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getChannelTypeCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-通道类型编码不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMessageChannelId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息通道ID不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMemberChannelRelationId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-成员通道关系ID不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getHandleType(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-处理类型不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getPlatformReplace(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-是否平台代操作不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getOperateTime(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-操作时间不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getSpaceId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-创建于空间ID不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getAppId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-创建于联盟应用ID不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getComNumField(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-通用数值字段（整数型）不能为空", false);
                    implementGroupSendMessagesNpeopleComRespDto = fwCompMessageClient.implementGroupSendMessagesNpeopleCom(implementGroupSendMessagesNpeopleComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
                    Assert.isTrue(implementGroupSendMessagesNpeopleComRespDto == null || implementGroupSendMessagesNpeopleComRespDto.getMessageId() == null, "找不到数据，系统异常", false);


                }
                QueryPushThirdPartyMessagesListComRespDto queryPushThirdPartyMessagesListComRespDto = null;
                if (implementPullNPeopleBuildGroupComRespDto != null) {
                    QueryPushThirdPartyMessagesListComReqDto queryPushThirdPartyMessagesListComReqDto = new QueryPushThirdPartyMessagesListComReqDto();
                    if (implementPullNPeopleBuildGroupComRespDto != null) {
                        queryPushThirdPartyMessagesListComReqDto.setMessageChannelId(implementPullNPeopleBuildGroupComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403938_1_56408
                    }
                    if (reqDto != null) {
                        queryPushThirdPartyMessagesListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403941_1_56408
                    }

                    /*D2查询推第三方问题列表(公共)[8126]   */
                    Assert.isNull(queryPushThirdPartyMessagesListComReqDto.getMessageChannelId(), "D3执行想问答(公共)-D2查询推第三方问题列表(公共)-消息通道ID不能为空", false);
                    Assert.isNull(queryPushThirdPartyMessagesListComReqDto.getSpaceId(), "D3执行想问答(公共)-D2查询推第三方问题列表(公共)-创建于空间ID不能为空", false);
                    queryPushThirdPartyMessagesListComRespDto = fwCompMessageClient.queryPushThirdPartyMessagesListCom(queryPushThirdPartyMessagesListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementGuidedThirdPartyIntelligentQaComRespDto implementGuidedThirdPartyIntelligentQaComRespDto = null;
                if (queryPushThirdPartyMessagesListComRespDto != null) {
                    ImplementGuidedThirdPartyIntelligentQaComReqDto implementGuidedThirdPartyIntelligentQaComReqDto = new ImplementGuidedThirdPartyIntelligentQaComReqDto();
                    implementGuidedThirdPartyIntelligentQaComReqDto.setBusModelVersion("PLUS_VERSION");//sourceId:2036958_1_56409
                    if (reqDto != null) {
                        implementGuidedThirdPartyIntelligentQaComReqDto.setResultAspObjId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403978_1_56409
                    }
                    if (queryPushThirdPartyMessagesListComRespDto != null && queryPushThirdPartyMessagesListComRespDto.getPushThirdPartyMessagesList() != null && !CollectionUtil.isEmpty(queryPushThirdPartyMessagesListComRespDto.getPushThirdPartyMessagesList())) {
                        implementGuidedThirdPartyIntelligentQaComReqDto.setGetListIntelligentAnswersList(//objList-to-objLists
                                queryPushThirdPartyMessagesListComRespDto.getPushThirdPartyMessagesList().stream().map(item -> {
                                    GetListIntelligentAnswersDto elm = new GetListIntelligentAnswersDto();
                                    if (item != null) {
                                        elm.setContent(item.getMessageContent());//SimpleFieldAssign//sourceId:282658_2_56409
                                        elm.setRole(item.getMessageRole());//SimpleFieldAssign//sourceId:282659_2_56409
                                    }
                                    return elm;
                                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1403979_1_56409
                    }

                    /*D2执行导向第三方智能问答(公共)[8103]   */
                    Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto.getResultAspObjId(), "D3执行想问答(公共)-D2执行导向第三方智能问答(公共)-开通对象ID不能为空", false);
                    Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto.getBusModelVersion(), "D3执行想问答(公共)-D2执行导向第三方智能问答(公共)-业务模型版本不能为空", false);
                    implementGuidedThirdPartyIntelligentQaComRespDto = fwCompIntelligentCommunicationClient.implementGuidedThirdPartyIntelligentQaCom(implementGuidedThirdPartyIntelligentQaComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                    implementGuidedThirdPartyIntelligentQaComRespDto_1 = implementGuidedThirdPartyIntelligentQaComRespDto;
                }
                QueryMemberChannelDetailComRespDto queryMemberChannelDetailComRespDto = null;
                if (implementPullNPeopleBuildGroupComRespDto != null && queryMemberProfileDetailComRespDto != null) {
                    QueryMemberChannelDetailComReqDto queryMemberChannelDetailComReqDto = new QueryMemberChannelDetailComReqDto();
                    queryMemberChannelDetailComReqDto.setBorcScene("TOB_SCENE");//sourceId:1403742_1_59875
                    if (implementPullNPeopleBuildGroupComRespDto != null) {
                        queryMemberChannelDetailComReqDto.setChannelId(implementPullNPeopleBuildGroupComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403741_1_59875
                    }
                    if (queryMemberProfileDetailComRespDto != null) {
                        queryMemberChannelDetailComReqDto.setOriginalRoleMemberId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403743_1_59875
                        queryMemberChannelDetailComReqDto.setUserId(queryMemberProfileDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403744_1_59875
                    }

                    /*D2查询成员通道详情(公共)[7305]   */
                    Assert.isNull(queryMemberChannelDetailComReqDto.getChannelId(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-通道ID不能为空", false);
                    Assert.isNull(queryMemberChannelDetailComReqDto.getBorcScene(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-toB或toC场景不能为空", false);
                    Assert.isNull(queryMemberChannelDetailComReqDto.getOriginalRoleMemberId(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-归属身份人员ID不能为空", false);
                    Assert.isNull(queryMemberChannelDetailComReqDto.getUserId(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-归属个人账号ID不能为空", false);
                    queryMemberChannelDetailComRespDto = fwCompMessageClient.queryMemberChannelDetailCom(queryMemberChannelDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementGroupSendMessagesNpeopleComRespDto implementGroupSendMessagesNpeopleComRespDto_2 = null;
                if (queryMemberProfileDetailComRespDto != null && implementGuidedThirdPartyIntelligentQaComRespDto != null && implementPullNPeopleBuildGroupComRespDto != null && queryMemberChannelDetailComRespDto != null) {
                    ImplementGroupSendMessagesNpeopleComReqDto implementGroupSendMessagesNpeopleComReqDto_1 = new ImplementGroupSendMessagesNpeopleComReqDto();
                    implementGroupSendMessagesNpeopleComReqDto_1.setBorcScene("TOB_SCENE");//sourceId:1403943_1_56410
                    implementGroupSendMessagesNpeopleComReqDto_1.setMessageLocationTypeCode("INTELLIGENT_STUDY");//CUSTOM_CONVENTION//sourceId:1403944_1_56410
                    implementGroupSendMessagesNpeopleComReqDto_1.setMessageTemplateCode("Q_AND_A_MESSAGE_TEMPLATE");//CUSTOM_CONVENTION//sourceId:1403952_1_56410
                    implementGroupSendMessagesNpeopleComReqDto_1.setIsAssistant("TRUE");//sourceId:1403961_1_56410
                    implementGroupSendMessagesNpeopleComReqDto_1.setMessageRole("system");//sourceId:1403945_1_56410
                    implementGroupSendMessagesNpeopleComReqDto_1.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1403958_1_56410
                    implementGroupSendMessagesNpeopleComReqDto_1.setMessageTitle("问题回答");//CUSTOM_CONVENTION//sourceId:1403967_1_56410
                    implementGroupSendMessagesNpeopleComReqDto_1.setHandleType("NO_NEED_HANDLING");//sourceId:1443706_1_56410
                    implementGroupSendMessagesNpeopleComReqDto_1.setPlatformReplace("FALSE");//sourceId:1403955_1_56410
                    implementGroupSendMessagesNpeopleComReqDto_1.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403966_1_56410
                    implementGroupSendMessagesNpeopleComReqDto_1.setComNumField(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1403960_1_56410
                    if (queryMemberProfileDetailComRespDto != null) {
                        implementGroupSendMessagesNpeopleComReqDto_1.setSenderOriginalRoleMemberId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403946_1_56410
                        implementGroupSendMessagesNpeopleComReqDto_1.setSenderUserId(queryMemberProfileDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403947_1_56410
                        implementGroupSendMessagesNpeopleComReqDto_1.setSenderProfilePictureAddress(queryMemberProfileDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1403948_1_56410
                        implementGroupSendMessagesNpeopleComReqDto_1.setNameOfSender(queryMemberProfileDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1403949_1_56410
                    }
                    if (reqDto != null) {
                        implementGroupSendMessagesNpeopleComReqDto_1.setSurfaceCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403950_1_56410
                        implementGroupSendMessagesNpeopleComReqDto_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1403951_1_56410
                        implementGroupSendMessagesNpeopleComReqDto_1.setMsgChannelClassCode(reqDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1447843_1_56410
                        implementGroupSendMessagesNpeopleComReqDto_1.setChannelTypeCode(reqDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403965_1_56410
                        implementGroupSendMessagesNpeopleComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403956_1_56410
                        implementGroupSendMessagesNpeopleComReqDto_1.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1403957_1_56410
                    }
                    if (implementGuidedThirdPartyIntelligentQaComRespDto != null) {
                        implementGroupSendMessagesNpeopleComReqDto_1.setMessageContent(implementGuidedThirdPartyIntelligentQaComRespDto.getContent());//SimpleFieldAssign//sourceId:1403959_1_56410
                    }
                    if (implementPullNPeopleBuildGroupComRespDto != null) {
                        implementGroupSendMessagesNpeopleComReqDto_1.setMessageChannelId(implementPullNPeopleBuildGroupComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403953_1_56410
                    }
                    if (queryMemberChannelDetailComRespDto != null) {
                        implementGroupSendMessagesNpeopleComReqDto_1.setMemberChannelRelationId(queryMemberChannelDetailComRespDto.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1443707_1_56410
                    }

                    /*D2执行群里会话发消息N人(第三方回答)[7028]   */
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getBorcScene(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-toB或toC场景不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMessageLocationTypeCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息位置标识不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMessageTemplateCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息模板标识不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getIsAssistant(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方是否助手不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMessageRole(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方角色不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getSenderOriginalRoleMemberId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方身份人员ID不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getSenderUserId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方账号ID不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getSenderProfilePictureAddress(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方头像地址不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getNameOfSender(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方姓名不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getSurfaceCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-归属内容类型编码不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getEntityId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-归属内容ID不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMessageImportantLevel(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息重要紧急度层级不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMessageTitle(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息标题不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMessageContent(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息内容不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getHandleType(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-处理类型不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMsgChannelClassCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息使用通道类别不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getChannelTypeCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-通道类型编码不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMessageChannelId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息通道ID不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMemberChannelRelationId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-成员通道关系ID不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getPlatformReplace(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-是否平台代操作不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getOperateTime(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-操作时间不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getSpaceId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-创建于空间ID不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getAppId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-创建于联盟应用ID不能为空", false);
                    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getComNumField(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-通用数值字段（整数型）不能为空", false);
                    implementGroupSendMessagesNpeopleComRespDto_2 = fwCompMessageClient.implementGroupSendMessagesNpeopleCom(implementGroupSendMessagesNpeopleComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                }
            } else if ((queryChannelDetailComRespDto != null && queryChannelDetailComRespDto.getMessageChannelId() != null)) {
                //elseif(D2查询通道详情(公共).通道ID 值不等于空 )  56411

                QueryMemberChannelDetailComRespDto queryMemberChannelDetailComRespDto_2 = null;
                if (queryChannelDetailComRespDto != null) {
                    QueryMemberChannelDetailComReqDto queryMemberChannelDetailComReqDto_1 = new QueryMemberChannelDetailComReqDto();
                    queryMemberChannelDetailComReqDto_1.setBorcScene("TOB_SCENE");//sourceId:1403742_1_56412
                    if (queryChannelDetailComRespDto != null) {
                        queryMemberChannelDetailComReqDto_1.setChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403741_1_56412
                    }
                    if (reqDto != null) {
                        queryMemberChannelDetailComReqDto_1.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403743_1_56412
                        queryMemberChannelDetailComReqDto_1.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1403744_1_56412
                    }

                    /*D2查询成员通道详情(公共)[7305]   */
                    Assert.isNull(queryMemberChannelDetailComReqDto_1.getChannelId(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-通道ID不能为空", false);
                    Assert.isNull(queryMemberChannelDetailComReqDto_1.getBorcScene(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-toB或toC场景不能为空", false);
                    Assert.isNull(queryMemberChannelDetailComReqDto_1.getOriginalRoleMemberId(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-归属身份人员ID不能为空", false);
                    Assert.isNull(queryMemberChannelDetailComReqDto_1.getUserId(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-归属个人账号ID不能为空", false);
                    queryMemberChannelDetailComRespDto_2 = fwCompMessageClient.queryMemberChannelDetailCom(queryMemberChannelDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                if ((queryMemberChannelDetailComRespDto_2 != null && queryMemberChannelDetailComRespDto_2.getMemberChannelRelationId() != null)) {
                    //if(D2查询提问身份人员成员通道详情(用于强提醒消息降级).成员通道关系ID 值不等于空 )  56413

                    ImplementGroupSendMessagesNpeopleComRespDto implementGroupSendMessagesNpeopleComRespDto_4 = null;
                    if (queryUserInfoDetailComRespDto != null && queryChannelDetailComRespDto != null && queryMemberChannelDetailComRespDto_2 != null) {
                        ImplementGroupSendMessagesNpeopleComReqDto implementGroupSendMessagesNpeopleComReqDto_2 = new ImplementGroupSendMessagesNpeopleComReqDto();
                        implementGroupSendMessagesNpeopleComReqDto_2.setBorcScene("TOB_SCENE");//sourceId:1403748_1_56415
                        implementGroupSendMessagesNpeopleComReqDto_2.setMessageLocationTypeCode("INTELLIGENT_STUDY");//CUSTOM_CONVENTION//sourceId:1403749_1_56415
                        implementGroupSendMessagesNpeopleComReqDto_2.setMessageTemplateCode("THIRD_QA_SESSION_MESSAGE_TEMPLATE");//CUSTOM_CONVENTION//sourceId:1403757_1_56415
                        implementGroupSendMessagesNpeopleComReqDto_2.setIsAssistant("FALSE");//sourceId:1403766_1_56415
                        implementGroupSendMessagesNpeopleComReqDto_2.setMessageRole("user");//sourceId:1403750_1_56415
                        implementGroupSendMessagesNpeopleComReqDto_2.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1403763_1_56415
                        implementGroupSendMessagesNpeopleComReqDto_2.setMessageTitle("我的问题");//CUSTOM_CONVENTION//sourceId:1403907_1_56415
                        implementGroupSendMessagesNpeopleComReqDto_2.setHandleType("NO_NEED_HANDLING");//sourceId:1443708_1_56415
                        implementGroupSendMessagesNpeopleComReqDto_2.setPlatformReplace("FALSE");//sourceId:1403760_1_56415
                        implementGroupSendMessagesNpeopleComReqDto_2.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403771_1_56415
                        implementGroupSendMessagesNpeopleComReqDto_2.setComNumField(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1403765_1_56415
                        if (reqDto != null) {
                            implementGroupSendMessagesNpeopleComReqDto_2.setSenderOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403906_1_56415
                            implementGroupSendMessagesNpeopleComReqDto_2.setSenderUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1403752_1_56415
                            implementGroupSendMessagesNpeopleComReqDto_2.setMessageContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1403764_1_56415
                            implementGroupSendMessagesNpeopleComReqDto_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403761_1_56415
                            implementGroupSendMessagesNpeopleComReqDto_2.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1403762_1_56415
                        }
                        if (queryUserInfoDetailComRespDto != null) {
                            implementGroupSendMessagesNpeopleComReqDto_2.setSenderProfilePictureAddress(queryUserInfoDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1403753_1_56415
                            implementGroupSendMessagesNpeopleComReqDto_2.setNameOfSender(queryUserInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1403754_1_56415
                        }
                        if (queryChannelDetailComRespDto != null) {
                            implementGroupSendMessagesNpeopleComReqDto_2.setSurfaceCode(queryChannelDetailComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403755_1_56415
                            implementGroupSendMessagesNpeopleComReqDto_2.setEntityId(queryChannelDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1403756_1_56415
                            implementGroupSendMessagesNpeopleComReqDto_2.setMsgChannelClassCode(queryChannelDetailComRespDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1447844_1_56415
                            implementGroupSendMessagesNpeopleComReqDto_2.setChannelTypeCode(queryChannelDetailComRespDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403770_1_56415
                            implementGroupSendMessagesNpeopleComReqDto_2.setMessageChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403758_1_56415
                        }
                        if (queryMemberChannelDetailComRespDto_2 != null) {
                            implementGroupSendMessagesNpeopleComReqDto_2.setMemberChannelRelationId(queryMemberChannelDetailComRespDto_2.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1443709_1_56415
                        }

                        /*D2执行群里会话发消息N人(提问)[7028]   */
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getBorcScene(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-toB或toC场景不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMessageLocationTypeCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息位置标识不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMessageTemplateCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息模板标识不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getIsAssistant(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方是否助手不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMessageRole(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方角色不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getSenderOriginalRoleMemberId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方身份人员ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getSenderUserId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方账号ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getSenderProfilePictureAddress(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方头像地址不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getNameOfSender(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方姓名不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getSurfaceCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-归属内容类型编码不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getEntityId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-归属内容ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMessageImportantLevel(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息重要紧急度层级不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMessageTitle(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息标题不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMessageContent(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息内容不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMsgChannelClassCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息使用通道类别不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getChannelTypeCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-通道类型编码不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMessageChannelId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息通道ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMemberChannelRelationId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-成员通道关系ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getHandleType(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-处理类型不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getPlatformReplace(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-是否平台代操作不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getOperateTime(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-操作时间不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getSpaceId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-创建于空间ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getAppId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-创建于联盟应用ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getComNumField(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-通用数值字段（整数型）不能为空", false);
                        implementGroupSendMessagesNpeopleComRespDto_4 = fwCompMessageClient.implementGroupSendMessagesNpeopleCom(implementGroupSendMessagesNpeopleComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;
                        Assert.isTrue(implementGroupSendMessagesNpeopleComRespDto_4 == null || implementGroupSendMessagesNpeopleComRespDto_4.getMessageId() == null, "找不到数据，系统异常", false);


                    }
                    QueryPushThirdPartyMessagesListComRespDto queryPushThirdPartyMessagesListComRespDto_2 = null;
                    if (queryChannelDetailComRespDto != null) {
                        QueryPushThirdPartyMessagesListComReqDto queryPushThirdPartyMessagesListComReqDto_1 = new QueryPushThirdPartyMessagesListComReqDto();
                        if (queryChannelDetailComRespDto != null) {
                            queryPushThirdPartyMessagesListComReqDto_1.setMessageChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403938_1_56418
                        }
                        if (reqDto != null) {
                            queryPushThirdPartyMessagesListComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403941_1_56418
                        }

                        /*D2查询推第三方问题列表(公共)[8126]   */
                        Assert.isNull(queryPushThirdPartyMessagesListComReqDto_1.getMessageChannelId(), "D3执行想问答(公共)-D2查询推第三方问题列表(公共)-消息通道ID不能为空", false);
                        Assert.isNull(queryPushThirdPartyMessagesListComReqDto_1.getSpaceId(), "D3执行想问答(公共)-D2查询推第三方问题列表(公共)-创建于空间ID不能为空", false);
                        queryPushThirdPartyMessagesListComRespDto_2 = fwCompMessageClient.queryPushThirdPartyMessagesListCom(queryPushThirdPartyMessagesListComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                    }
                    ImplementGuidedThirdPartyIntelligentQaComRespDto implementGuidedThirdPartyIntelligentQaComRespDto_2 = null;
                    if (queryPushThirdPartyMessagesListComRespDto_2 != null) {
                        ImplementGuidedThirdPartyIntelligentQaComReqDto implementGuidedThirdPartyIntelligentQaComReqDto_1 = new ImplementGuidedThirdPartyIntelligentQaComReqDto();
                        implementGuidedThirdPartyIntelligentQaComReqDto_1.setBusModelVersion("PLUS_VERSION");//sourceId:2036958_1_56419
                        if (reqDto != null) {
                            implementGuidedThirdPartyIntelligentQaComReqDto_1.setResultAspObjId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403978_1_56419
                        }
                        if (queryPushThirdPartyMessagesListComRespDto_2 != null && queryPushThirdPartyMessagesListComRespDto_2.getPushThirdPartyMessagesList() != null && !CollectionUtil.isEmpty(queryPushThirdPartyMessagesListComRespDto_2.getPushThirdPartyMessagesList())) {
                            implementGuidedThirdPartyIntelligentQaComReqDto_1.setGetListIntelligentAnswersList(//objList-to-objLists
                                    queryPushThirdPartyMessagesListComRespDto_2.getPushThirdPartyMessagesList().stream().map(item -> {
                                        GetListIntelligentAnswersDto elm = new GetListIntelligentAnswersDto();
                                        if (item != null) {
                                            elm.setContent(item.getMessageContent());//SimpleFieldAssign//sourceId:282658_2_56419
                                            elm.setRole(item.getMessageRole());//SimpleFieldAssign//sourceId:282659_2_56419
                                        }
                                        return elm;
                                    }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1403979_1_56419
                        }

                        /*D2执行导向第三方智能问答(公共)[8103]   */
                        Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto_1.getResultAspObjId(), "D3执行想问答(公共)-D2执行导向第三方智能问答(公共)-开通对象ID不能为空", false);
                        Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto_1.getBusModelVersion(), "D3执行想问答(公共)-D2执行导向第三方智能问答(公共)-业务模型版本不能为空", false);
                        implementGuidedThirdPartyIntelligentQaComRespDto_2 = fwCompIntelligentCommunicationClient.implementGuidedThirdPartyIntelligentQaCom(implementGuidedThirdPartyIntelligentQaComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                        implementGuidedThirdPartyIntelligentQaComRespDto_1 = implementGuidedThirdPartyIntelligentQaComRespDto_2;
                    }
                    QueryMemberChannelDetailComRespDto queryMemberChannelDetailComRespDto_3 = null;
                    if (queryChannelDetailComRespDto != null && queryMemberProfileDetailComRespDto != null) {
                        QueryMemberChannelDetailComReqDto queryMemberChannelDetailComReqDto_2 = new QueryMemberChannelDetailComReqDto();
                        queryMemberChannelDetailComReqDto_2.setBorcScene("TOB_SCENE");//sourceId:1403742_1_59876
                        if (queryChannelDetailComRespDto != null) {
                            queryMemberChannelDetailComReqDto_2.setChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403741_1_59876
                        }
                        if (queryMemberProfileDetailComRespDto != null) {
                            queryMemberChannelDetailComReqDto_2.setOriginalRoleMemberId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403743_1_59876
                            queryMemberChannelDetailComReqDto_2.setUserId(queryMemberProfileDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403744_1_59876
                        }

                        /*D2查询成员通道详情(公共)[7305]   */
                        Assert.isNull(queryMemberChannelDetailComReqDto_2.getChannelId(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-通道ID不能为空", false);
                        Assert.isNull(queryMemberChannelDetailComReqDto_2.getBorcScene(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-toB或toC场景不能为空", false);
                        Assert.isNull(queryMemberChannelDetailComReqDto_2.getOriginalRoleMemberId(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-归属身份人员ID不能为空", false);
                        Assert.isNull(queryMemberChannelDetailComReqDto_2.getUserId(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-归属个人账号ID不能为空", false);
                        queryMemberChannelDetailComRespDto_3 = fwCompMessageClient.queryMemberChannelDetailCom(queryMemberChannelDetailComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


                    }
                    ImplementGroupSendMessagesNpeopleComRespDto implementGroupSendMessagesNpeopleComRespDto_5 = null;
                    if (queryMemberProfileDetailComRespDto != null && queryChannelDetailComRespDto != null && implementGuidedThirdPartyIntelligentQaComRespDto_2 != null && queryMemberChannelDetailComRespDto_3 != null) {
                        ImplementGroupSendMessagesNpeopleComReqDto implementGroupSendMessagesNpeopleComReqDto_3 = new ImplementGroupSendMessagesNpeopleComReqDto();
                        implementGroupSendMessagesNpeopleComReqDto_3.setBorcScene("TOB_SCENE");//sourceId:1403943_1_56420
                        implementGroupSendMessagesNpeopleComReqDto_3.setMessageLocationTypeCode("INTELLIGENT_STUDY");//CUSTOM_CONVENTION//sourceId:1403944_1_56420
                        implementGroupSendMessagesNpeopleComReqDto_3.setMessageTemplateCode("Q_AND_A_MESSAGE_TEMPLATE");//CUSTOM_CONVENTION//sourceId:1403952_1_56420
                        implementGroupSendMessagesNpeopleComReqDto_3.setIsAssistant("TRUE");//sourceId:1403961_1_56420
                        implementGroupSendMessagesNpeopleComReqDto_3.setMessageRole("system");//sourceId:1403945_1_56420
                        implementGroupSendMessagesNpeopleComReqDto_3.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1403958_1_56420
                        implementGroupSendMessagesNpeopleComReqDto_3.setMessageTitle("问题回答");//CUSTOM_CONVENTION//sourceId:1403967_1_56420
                        implementGroupSendMessagesNpeopleComReqDto_3.setHandleType("NO_NEED_HANDLING");//sourceId:1443706_1_56420
                        implementGroupSendMessagesNpeopleComReqDto_3.setPlatformReplace("FALSE");//sourceId:1403955_1_56420
                        implementGroupSendMessagesNpeopleComReqDto_3.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403966_1_56420
                        implementGroupSendMessagesNpeopleComReqDto_3.setComNumField(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1403960_1_56420
                        if (queryMemberProfileDetailComRespDto != null) {
                            implementGroupSendMessagesNpeopleComReqDto_3.setSenderOriginalRoleMemberId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403946_1_56420
                            implementGroupSendMessagesNpeopleComReqDto_3.setSenderUserId(queryMemberProfileDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403947_1_56420
                            implementGroupSendMessagesNpeopleComReqDto_3.setSenderProfilePictureAddress(queryMemberProfileDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1403948_1_56420
                            implementGroupSendMessagesNpeopleComReqDto_3.setNameOfSender(queryMemberProfileDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1403949_1_56420
                        }
                        if (queryChannelDetailComRespDto != null) {
                            implementGroupSendMessagesNpeopleComReqDto_3.setSurfaceCode(queryChannelDetailComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403950_1_56420
                            implementGroupSendMessagesNpeopleComReqDto_3.setEntityId(queryChannelDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1403951_1_56420
                            implementGroupSendMessagesNpeopleComReqDto_3.setMsgChannelClassCode(queryChannelDetailComRespDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1447843_1_56420
                            implementGroupSendMessagesNpeopleComReqDto_3.setChannelTypeCode(queryChannelDetailComRespDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403965_1_56420
                            implementGroupSendMessagesNpeopleComReqDto_3.setMessageChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403953_1_56420
                        }
                        if (implementGuidedThirdPartyIntelligentQaComRespDto_2 != null) {
                            implementGroupSendMessagesNpeopleComReqDto_3.setMessageContent(implementGuidedThirdPartyIntelligentQaComRespDto_2.getContent());//SimpleFieldAssign//sourceId:1403959_1_56420
                        }
                        if (queryMemberChannelDetailComRespDto_3 != null) {
                            implementGroupSendMessagesNpeopleComReqDto_3.setMemberChannelRelationId(queryMemberChannelDetailComRespDto_3.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1443707_1_56420
                        }
                        if (reqDto != null) {
                            implementGroupSendMessagesNpeopleComReqDto_3.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403956_1_56420
                            implementGroupSendMessagesNpeopleComReqDto_3.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1403957_1_56420
                        }

                        /*D2执行群里会话发消息N人(第三方回答)[7028]   */
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getBorcScene(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-toB或toC场景不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMessageLocationTypeCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息位置标识不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMessageTemplateCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息模板标识不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getIsAssistant(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方是否助手不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMessageRole(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方角色不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getSenderOriginalRoleMemberId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方身份人员ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getSenderUserId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方账号ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getSenderProfilePictureAddress(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方头像地址不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getNameOfSender(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方姓名不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getSurfaceCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-归属内容类型编码不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getEntityId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-归属内容ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMessageImportantLevel(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息重要紧急度层级不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMessageTitle(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息标题不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMessageContent(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息内容不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getHandleType(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-处理类型不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMsgChannelClassCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息使用通道类别不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getChannelTypeCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-通道类型编码不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMessageChannelId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息通道ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMemberChannelRelationId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-成员通道关系ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getPlatformReplace(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-是否平台代操作不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getOperateTime(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-操作时间不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getSpaceId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-创建于空间ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getAppId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-创建于联盟应用ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getComNumField(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-通用数值字段（整数型）不能为空", false);
                        implementGroupSendMessagesNpeopleComRespDto_5 = fwCompMessageClient.implementGroupSendMessagesNpeopleCom(implementGroupSendMessagesNpeopleComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


                    }
                } else if ((queryMemberChannelDetailComRespDto_2 != null && queryMemberChannelDetailComRespDto_2.getMemberChannelRelationId() == null)) {
                    //elseif(D2查询提问身份人员成员通道详情(用于强提醒消息降级).成员通道关系ID 值等于空 )  56414

                    ImplementInitializationMemberChannelComRespDto implementInitializationMemberChannelComRespDto = null;
                    if (queryChannelDetailComRespDto != null && queryMemberProfileDetailComRespDto != null && queryMeMessageVirtualImageDetailComRespDto != null) {
                        ImplementInitializationMemberChannelComReqDto implementInitializationMemberChannelComReqDto = new ImplementInitializationMemberChannelComReqDto();
                        implementInitializationMemberChannelComReqDto.setUseChannelMethod("ISHAVE_CHANNEL");//sourceId:1403721_1_56416
                        implementInitializationMemberChannelComReqDto.setMessageTemplateCode("THIRD_QA_SESSION_MESSAGE_TEMPLATE");//CUSTOM_CONVENTION//sourceId:1403714_1_56416
                        implementInitializationMemberChannelComReqDto.setChannelName("我的智能问答");//CUSTOM_CONVENTION//sourceId:1403722_1_56416
                        implementInitializationMemberChannelComReqDto.setBorcScene("TOB_SCENE");//sourceId:1403725_1_56416
                        implementInitializationMemberChannelComReqDto.setIsAssistant("FALSE");//sourceId:1403864_1_56416
                        implementInitializationMemberChannelComReqDto.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403740_1_56416
                        if (reqDto != null) {
                            implementInitializationMemberChannelComReqDto.setChannelTypeCode(reqDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403739_1_56416
                            implementInitializationMemberChannelComReqDto.setNewMessage(reqDto.getContent());//SimpleFieldAssign//sourceId:1403724_1_56416
                            implementInitializationMemberChannelComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403726_1_56416
                            implementInitializationMemberChannelComReqDto.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1403727_1_56416
                        }
                        if (queryChannelDetailComRespDto != null) {
                            implementInitializationMemberChannelComReqDto.setMsgChannelClassCode(queryChannelDetailComRespDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1477056_1_56416
                            implementInitializationMemberChannelComReqDto.setChannelLogo(queryChannelDetailComRespDto.getChannelLogo());//SimpleFieldAssign//sourceId:1403723_1_56416
                            implementInitializationMemberChannelComReqDto.setNewTableTypeCode(queryChannelDetailComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403730_1_56416
                            implementInitializationMemberChannelComReqDto.setNewEntityId(queryChannelDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1403731_1_56416
                            implementInitializationMemberChannelComReqDto.setChannelSpaceId(queryChannelDetailComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1403735_1_56416
                            implementInitializationMemberChannelComReqDto.setChannelAppId(queryChannelDetailComRespDto.getAppId());//SimpleFieldAssign//sourceId:1403736_1_56416
                            implementInitializationMemberChannelComReqDto.setSpaceId(queryChannelDetailComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1403728_1_56416
                        }
                        if (queryMemberProfileDetailComRespDto != null) {
                            implementInitializationMemberChannelComReqDto.setCounterpartEntityId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403732_1_56416
                            implementInitializationMemberChannelComReqDto.setCounterpartChannelLogo(queryMemberProfileDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1403733_1_56416
                            implementInitializationMemberChannelComReqDto.setCounterpartChannelName(queryMemberProfileDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1403734_1_56416
                            implementInitializationMemberChannelComReqDto.setAppId(queryMemberProfileDetailComRespDto.getAppId());//SimpleFieldAssign//sourceId:1403729_1_56416
                        }
                        if (queryMeMessageVirtualImageDetailComRespDto != null) {
                            implementInitializationMemberChannelComReqDto.setVirtualImageCode(queryMeMessageVirtualImageDetailComRespDto.getVirtualImageCode());//SimpleFieldAssign//sourceId:1403737_1_56416
                        }

                        /*D2执行初始化成员通道(公共)[6804]   */
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getUseChannelMethod(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-使用通道方式不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getMessageTemplateCode(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-消息模板标识不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getChannelTypeCode(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-通道类型编码不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getMsgChannelClassCode(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-消息使用通道类别不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getChannelName(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-通道名称不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getChannelLogo(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-通道缩略图地址不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getNewTableTypeCode(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-通道归属主体内容类型编码不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getNewEntityId(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-通道归属主体内容ID不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getChannelSpaceId(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-通道归属空间ID不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getChannelAppId(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-通道归属联盟应用ID不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getNewMessage(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-最新消息文本不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getUserId(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-归属个人账号ID不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getBorcScene(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-toB或toC场景不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getCounterpartEntityId(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-发送方是员工或个人ID不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getCounterpartChannelLogo(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-发送方缩略图地址不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getCounterpartChannelName(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-发送方名称不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getIsAssistant(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-发送方是否助手不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getOperateTime(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-操作时间不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getSpaceId(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-创建于空间ID不能为空", false);
                        Assert.isNull(implementInitializationMemberChannelComReqDto.getAppId(), "D3执行想问答(公共)-D2执行初始化成员通道(公共)-创建于联盟应用ID不能为空", false);
                        implementInitializationMemberChannelComRespDto = fwCompMessageClient.implementInitializationMemberChannelCom(implementInitializationMemberChannelComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                    }
                    ImplementNewInitializationMessageNumComRespDto implementNewInitializationMessageNumComRespDto = null;
                    if (implementInitializationMemberChannelComRespDto != null) {
                        ImplementNewInitializationMessageNumComReqDto implementNewInitializationMessageNumComReqDto = new ImplementNewInitializationMessageNumComReqDto();
                        implementNewInitializationMessageNumComReqDto.setSurfaceCode("MEMBER_CHANNEL_RELATION");//sourceId:1492428_1_59871
                        if (implementInitializationMemberChannelComRespDto != null) {
                            implementNewInitializationMessageNumComReqDto.setEntityId(implementInitializationMemberChannelComRespDto.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1492429_1_59871
                            implementNewInitializationMessageNumComReqDto.setMessageChannelId(implementInitializationMemberChannelComRespDto.getChannelId());//SimpleFieldAssign//sourceId:1492431_1_59871
                        }
                        if (reqDto != null) {
                            implementNewInitializationMessageNumComReqDto.setChannelTypeCode(reqDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1492430_1_59871
                            implementNewInitializationMessageNumComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1492432_1_59871
                            implementNewInitializationMessageNumComReqDto.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1492433_1_59871
                            implementNewInitializationMessageNumComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1492434_1_59871
                        }

                        /*D2-执行初始化消息数量（新）(公共)[7908]   */
                        Assert.isNull(implementNewInitializationMessageNumComReqDto.getSurfaceCode(), "D3执行想问答(公共)-D2-执行初始化消息数量（新）(公共)-归属内容类型编码不能为空", false);
                        Assert.isNull(implementNewInitializationMessageNumComReqDto.getEntityId(), "D3执行想问答(公共)-D2-执行初始化消息数量（新）(公共)-归属内容ID不能为空", false);
                        Assert.isNull(implementNewInitializationMessageNumComReqDto.getChannelTypeCode(), "D3执行想问答(公共)-D2-执行初始化消息数量（新）(公共)-通道类型编码不能为空", false);
                        Assert.isNull(implementNewInitializationMessageNumComReqDto.getMessageChannelId(), "D3执行想问答(公共)-D2-执行初始化消息数量（新）(公共)-消息通道ID不能为空", false);
                        Assert.isNull(implementNewInitializationMessageNumComReqDto.getOriginalRoleMemberId(), "D3执行想问答(公共)-D2-执行初始化消息数量（新）(公共)-身份人员ID不能为空", false);
                        Assert.isNull(implementNewInitializationMessageNumComReqDto.getUserId(), "D3执行想问答(公共)-D2-执行初始化消息数量（新）(公共)-账号不能为空", false);
                        Assert.isNull(implementNewInitializationMessageNumComReqDto.getSpaceId(), "D3执行想问答(公共)-D2-执行初始化消息数量（新）(公共)-创建于空间ID不能为空", false);
                        implementNewInitializationMessageNumComRespDto = fwCompMessageClient.implementNewInitializationMessageNumCom(implementNewInitializationMessageNumComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                    }
                    ImplementGroupSendMessagesNpeopleComRespDto implementGroupSendMessagesNpeopleComRespDto_6 = null;
                    if (queryUserInfoDetailComRespDto != null && queryChannelDetailComRespDto != null && implementInitializationMemberChannelComRespDto != null) {
                        ImplementGroupSendMessagesNpeopleComReqDto implementGroupSendMessagesNpeopleComReqDto_4 = new ImplementGroupSendMessagesNpeopleComReqDto();
                        implementGroupSendMessagesNpeopleComReqDto_4.setBorcScene("TOB_SCENE");//sourceId:1403748_1_56417
                        implementGroupSendMessagesNpeopleComReqDto_4.setMessageLocationTypeCode("INTELLIGENT_STUDY");//CUSTOM_CONVENTION//sourceId:1403749_1_56417
                        implementGroupSendMessagesNpeopleComReqDto_4.setMessageTemplateCode("THIRD_QA_SESSION_MESSAGE_TEMPLATE");//CUSTOM_CONVENTION//sourceId:1403757_1_56417
                        implementGroupSendMessagesNpeopleComReqDto_4.setIsAssistant("FALSE");//sourceId:1403766_1_56417
                        implementGroupSendMessagesNpeopleComReqDto_4.setMessageRole("user");//sourceId:1403750_1_56417
                        implementGroupSendMessagesNpeopleComReqDto_4.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1403763_1_56417
                        implementGroupSendMessagesNpeopleComReqDto_4.setMessageTitle("我的问题");//CUSTOM_CONVENTION//sourceId:1403907_1_56417
                        implementGroupSendMessagesNpeopleComReqDto_4.setHandleType("NO_NEED_HANDLING");//sourceId:1443708_1_56417
                        implementGroupSendMessagesNpeopleComReqDto_4.setPlatformReplace("FALSE");//sourceId:1403760_1_56417
                        implementGroupSendMessagesNpeopleComReqDto_4.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403771_1_56417
                        implementGroupSendMessagesNpeopleComReqDto_4.setComNumField(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1403765_1_56417
                        if (reqDto != null) {
                            implementGroupSendMessagesNpeopleComReqDto_4.setSenderOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403906_1_56417
                            implementGroupSendMessagesNpeopleComReqDto_4.setSenderUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1403752_1_56417
                            implementGroupSendMessagesNpeopleComReqDto_4.setMessageContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1403764_1_56417
                            implementGroupSendMessagesNpeopleComReqDto_4.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403761_1_56417
                            implementGroupSendMessagesNpeopleComReqDto_4.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1403762_1_56417
                        }
                        if (queryUserInfoDetailComRespDto != null) {
                            implementGroupSendMessagesNpeopleComReqDto_4.setSenderProfilePictureAddress(queryUserInfoDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1403753_1_56417
                            implementGroupSendMessagesNpeopleComReqDto_4.setNameOfSender(queryUserInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1403754_1_56417
                        }
                        if (queryChannelDetailComRespDto != null) {
                            implementGroupSendMessagesNpeopleComReqDto_4.setSurfaceCode(queryChannelDetailComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403755_1_56417
                            implementGroupSendMessagesNpeopleComReqDto_4.setEntityId(queryChannelDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1403756_1_56417
                            implementGroupSendMessagesNpeopleComReqDto_4.setMsgChannelClassCode(queryChannelDetailComRespDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1447844_1_56417
                            implementGroupSendMessagesNpeopleComReqDto_4.setChannelTypeCode(queryChannelDetailComRespDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403770_1_56417
                            implementGroupSendMessagesNpeopleComReqDto_4.setMessageChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403758_1_56417
                        }
                        if (implementInitializationMemberChannelComRespDto != null) {
                            implementGroupSendMessagesNpeopleComReqDto_4.setMemberChannelRelationId(implementInitializationMemberChannelComRespDto.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1443709_1_56417
                        }

                        /*D2执行群里会话发消息N人(提问)[7028]   */
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getBorcScene(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-toB或toC场景不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMessageLocationTypeCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息位置标识不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMessageTemplateCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息模板标识不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getIsAssistant(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方是否助手不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMessageRole(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方角色不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getSenderOriginalRoleMemberId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方身份人员ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getSenderUserId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方账号ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getSenderProfilePictureAddress(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方头像地址不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getNameOfSender(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方姓名不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getSurfaceCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-归属内容类型编码不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getEntityId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-归属内容ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMessageImportantLevel(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息重要紧急度层级不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMessageTitle(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息标题不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMessageContent(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息内容不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMsgChannelClassCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息使用通道类别不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getChannelTypeCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-通道类型编码不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMessageChannelId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息通道ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMemberChannelRelationId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-成员通道关系ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getHandleType(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-处理类型不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getPlatformReplace(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-是否平台代操作不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getOperateTime(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-操作时间不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getSpaceId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-创建于空间ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getAppId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-创建于联盟应用ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getComNumField(), "D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-通用数值字段（整数型）不能为空", false);
                        implementGroupSendMessagesNpeopleComRespDto_6 = fwCompMessageClient.implementGroupSendMessagesNpeopleCom(implementGroupSendMessagesNpeopleComReqDto_4).getData()/*vcase invoke 跨dubbo调用;*/;
                        Assert.isTrue(implementGroupSendMessagesNpeopleComRespDto_6 == null || implementGroupSendMessagesNpeopleComRespDto_6.getMessageId() == null, "找不到数据，系统异常", false);


                    }
                    QueryPushThirdPartyMessagesListComRespDto queryPushThirdPartyMessagesListComRespDto_3 = null;
                    if (queryChannelDetailComRespDto != null) {
                        QueryPushThirdPartyMessagesListComReqDto queryPushThirdPartyMessagesListComReqDto_2 = new QueryPushThirdPartyMessagesListComReqDto();
                        if (queryChannelDetailComRespDto != null) {
                            queryPushThirdPartyMessagesListComReqDto_2.setMessageChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403938_1_56421
                        }
                        if (reqDto != null) {
                            queryPushThirdPartyMessagesListComReqDto_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403941_1_56421
                        }

                        /*D2查询推第三方问题列表(公共)[8126]   */
                        Assert.isNull(queryPushThirdPartyMessagesListComReqDto_2.getMessageChannelId(), "D3执行想问答(公共)-D2查询推第三方问题列表(公共)-消息通道ID不能为空", false);
                        Assert.isNull(queryPushThirdPartyMessagesListComReqDto_2.getSpaceId(), "D3执行想问答(公共)-D2查询推第三方问题列表(公共)-创建于空间ID不能为空", false);
                        queryPushThirdPartyMessagesListComRespDto_3 = fwCompMessageClient.queryPushThirdPartyMessagesListCom(queryPushThirdPartyMessagesListComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


                    }
                    ImplementGuidedThirdPartyIntelligentQaComRespDto implementGuidedThirdPartyIntelligentQaComRespDto_3 = null;
                    if (queryPushThirdPartyMessagesListComRespDto_3 != null) {
                        ImplementGuidedThirdPartyIntelligentQaComReqDto implementGuidedThirdPartyIntelligentQaComReqDto_2 = new ImplementGuidedThirdPartyIntelligentQaComReqDto();
                        implementGuidedThirdPartyIntelligentQaComReqDto_2.setBusModelVersion("PLUS_VERSION");//sourceId:2036958_1_56422
                        if (reqDto != null) {
                            implementGuidedThirdPartyIntelligentQaComReqDto_2.setResultAspObjId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403978_1_56422
                        }
                        if (queryPushThirdPartyMessagesListComRespDto_3 != null && queryPushThirdPartyMessagesListComRespDto_3.getPushThirdPartyMessagesList() != null && !CollectionUtil.isEmpty(queryPushThirdPartyMessagesListComRespDto_3.getPushThirdPartyMessagesList())) {
                            implementGuidedThirdPartyIntelligentQaComReqDto_2.setGetListIntelligentAnswersList(//objList-to-objLists
                                    queryPushThirdPartyMessagesListComRespDto_3.getPushThirdPartyMessagesList().stream().map(item -> {
                                        GetListIntelligentAnswersDto elm = new GetListIntelligentAnswersDto();
                                        if (item != null) {
                                            elm.setContent(item.getMessageContent());//SimpleFieldAssign//sourceId:282658_2_56422
                                            elm.setRole(item.getMessageRole());//SimpleFieldAssign//sourceId:282659_2_56422
                                        }
                                        return elm;
                                    }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1403979_1_56422
                        }

                        /*D2执行导向第三方智能问答(公共)[8103]   */
                        Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto_2.getResultAspObjId(), "D3执行想问答(公共)-D2执行导向第三方智能问答(公共)-开通对象ID不能为空", false);
                        Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto_2.getBusModelVersion(), "D3执行想问答(公共)-D2执行导向第三方智能问答(公共)-业务模型版本不能为空", false);
                        implementGuidedThirdPartyIntelligentQaComRespDto_3 = fwCompIntelligentCommunicationClient.implementGuidedThirdPartyIntelligentQaCom(implementGuidedThirdPartyIntelligentQaComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


                        implementGuidedThirdPartyIntelligentQaComRespDto_1 = implementGuidedThirdPartyIntelligentQaComRespDto_3;
                    }
                    QueryMemberChannelDetailComRespDto queryMemberChannelDetailComRespDto_4 = null;
                    if (queryChannelDetailComRespDto != null && queryMemberProfileDetailComRespDto != null) {
                        QueryMemberChannelDetailComReqDto queryMemberChannelDetailComReqDto_3 = new QueryMemberChannelDetailComReqDto();
                        queryMemberChannelDetailComReqDto_3.setBorcScene("TOB_SCENE");//sourceId:1403742_1_59877
                        if (queryChannelDetailComRespDto != null) {
                            queryMemberChannelDetailComReqDto_3.setChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403741_1_59877
                        }
                        if (queryMemberProfileDetailComRespDto != null) {
                            queryMemberChannelDetailComReqDto_3.setOriginalRoleMemberId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403743_1_59877
                            queryMemberChannelDetailComReqDto_3.setUserId(queryMemberProfileDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403744_1_59877
                        }

                        /*D2查询成员通道详情(公共)[7305]   */
                        Assert.isNull(queryMemberChannelDetailComReqDto_3.getChannelId(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-通道ID不能为空", false);
                        Assert.isNull(queryMemberChannelDetailComReqDto_3.getBorcScene(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-toB或toC场景不能为空", false);
                        Assert.isNull(queryMemberChannelDetailComReqDto_3.getOriginalRoleMemberId(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-归属身份人员ID不能为空", false);
                        Assert.isNull(queryMemberChannelDetailComReqDto_3.getUserId(), "D3执行想问答(公共)-D2查询成员通道详情(公共)-归属个人账号ID不能为空", false);
                        queryMemberChannelDetailComRespDto_4 = fwCompMessageClient.queryMemberChannelDetailCom(queryMemberChannelDetailComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


                    }
                    ImplementGroupSendMessagesNpeopleComRespDto implementGroupSendMessagesNpeopleComRespDto_7 = null;
                    if (queryMemberProfileDetailComRespDto != null && queryChannelDetailComRespDto != null && implementGuidedThirdPartyIntelligentQaComRespDto_3 != null && queryMemberChannelDetailComRespDto_4 != null) {
                        ImplementGroupSendMessagesNpeopleComReqDto implementGroupSendMessagesNpeopleComReqDto_5 = new ImplementGroupSendMessagesNpeopleComReqDto();
                        implementGroupSendMessagesNpeopleComReqDto_5.setBorcScene("TOB_SCENE");//sourceId:1403943_1_56423
                        implementGroupSendMessagesNpeopleComReqDto_5.setMessageLocationTypeCode("INTELLIGENT_STUDY");//CUSTOM_CONVENTION//sourceId:1403944_1_56423
                        implementGroupSendMessagesNpeopleComReqDto_5.setMessageTemplateCode("Q_AND_A_MESSAGE_TEMPLATE");//CUSTOM_CONVENTION//sourceId:1403952_1_56423
                        implementGroupSendMessagesNpeopleComReqDto_5.setIsAssistant("TRUE");//sourceId:1403961_1_56423
                        implementGroupSendMessagesNpeopleComReqDto_5.setMessageRole("system");//sourceId:1403945_1_56423
                        implementGroupSendMessagesNpeopleComReqDto_5.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1403958_1_56423
                        implementGroupSendMessagesNpeopleComReqDto_5.setMessageTitle("问题回答");//CUSTOM_CONVENTION//sourceId:1403967_1_56423
                        implementGroupSendMessagesNpeopleComReqDto_5.setHandleType("NO_NEED_HANDLING");//sourceId:1443706_1_56423
                        implementGroupSendMessagesNpeopleComReqDto_5.setPlatformReplace("FALSE");//sourceId:1403955_1_56423
                        implementGroupSendMessagesNpeopleComReqDto_5.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403966_1_56423
                        implementGroupSendMessagesNpeopleComReqDto_5.setComNumField(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1403960_1_56423
                        if (queryMemberProfileDetailComRespDto != null) {
                            implementGroupSendMessagesNpeopleComReqDto_5.setSenderOriginalRoleMemberId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403946_1_56423
                            implementGroupSendMessagesNpeopleComReqDto_5.setSenderUserId(queryMemberProfileDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403947_1_56423
                            implementGroupSendMessagesNpeopleComReqDto_5.setSenderProfilePictureAddress(queryMemberProfileDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1403948_1_56423
                            implementGroupSendMessagesNpeopleComReqDto_5.setNameOfSender(queryMemberProfileDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1403949_1_56423
                        }
                        if (queryChannelDetailComRespDto != null) {
                            implementGroupSendMessagesNpeopleComReqDto_5.setSurfaceCode(queryChannelDetailComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403950_1_56423
                            implementGroupSendMessagesNpeopleComReqDto_5.setEntityId(queryChannelDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1403951_1_56423
                            implementGroupSendMessagesNpeopleComReqDto_5.setMsgChannelClassCode(queryChannelDetailComRespDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1447843_1_56423
                            implementGroupSendMessagesNpeopleComReqDto_5.setChannelTypeCode(queryChannelDetailComRespDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403965_1_56423
                            implementGroupSendMessagesNpeopleComReqDto_5.setMessageChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403953_1_56423
                        }
                        if (implementGuidedThirdPartyIntelligentQaComRespDto_3 != null) {
                            implementGroupSendMessagesNpeopleComReqDto_5.setMessageContent(implementGuidedThirdPartyIntelligentQaComRespDto_3.getContent());//SimpleFieldAssign//sourceId:1403959_1_56423
                        }
                        if (queryMemberChannelDetailComRespDto_4 != null) {
                            implementGroupSendMessagesNpeopleComReqDto_5.setMemberChannelRelationId(queryMemberChannelDetailComRespDto_4.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1443707_1_56423
                        }
                        if (reqDto != null) {
                            implementGroupSendMessagesNpeopleComReqDto_5.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403956_1_56423
                            implementGroupSendMessagesNpeopleComReqDto_5.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1403957_1_56423
                        }

                        /*D2执行群里会话发消息N人(第三方回答)[7028]   */
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getBorcScene(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-toB或toC场景不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMessageLocationTypeCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息位置标识不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMessageTemplateCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息模板标识不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getIsAssistant(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方是否助手不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMessageRole(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方角色不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getSenderOriginalRoleMemberId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方身份人员ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getSenderUserId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方账号ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getSenderProfilePictureAddress(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方头像地址不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getNameOfSender(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方姓名不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getSurfaceCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-归属内容类型编码不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getEntityId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-归属内容ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMessageImportantLevel(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息重要紧急度层级不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMessageTitle(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息标题不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMessageContent(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息内容不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getHandleType(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-处理类型不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMsgChannelClassCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息使用通道类别不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getChannelTypeCode(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-通道类型编码不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMessageChannelId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息通道ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMemberChannelRelationId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-成员通道关系ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getPlatformReplace(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-是否平台代操作不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getOperateTime(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-操作时间不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getSpaceId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-创建于空间ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getAppId(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-创建于联盟应用ID不能为空", false);
                        Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getComNumField(), "D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-通用数值字段（整数型）不能为空", false);
                        implementGroupSendMessagesNpeopleComRespDto_7 = fwCompMessageClient.implementGroupSendMessagesNpeopleCom(implementGroupSendMessagesNpeopleComReqDto_5).getData()/*vcase invoke 跨dubbo调用;*/;


                    }
                }
            }
        }
        ImplementWantAskAnswerComRespDto retData = new ImplementWantAskAnswerComRespDto();
        if (implementGuidedThirdPartyIntelligentQaComRespDto_1 != null) {
            retData.setContent(implementGuidedThirdPartyIntelligentQaComRespDto_1.getContent());//SimpleFieldAssign//sourceId:1403982_1
        }


        return retData;
    }

    /**
     * D3执行记录想法(公共)[8289]
     * gen by moon at 12/13/2024, 11:12:25 PM
     */
    @Trace(operationName = "D3执行记录想法(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementRecordIdeasComRespDto implementRecordIdeasCom(ImplementRecordIdeasComReqDto reqDto) {


        ImplementCreateMsgAndNumComRespDto implementCreateMsgAndNumComRespDto_1 = null;
        //步骤0: M3执行第四接收字段（特殊方法） - implementFourthReceivingField
        //ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes = null;
        ImplementFourthReceivingFieldReqDto receptionServiceReq = new ImplementFourthReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1479288_1
            receptionServiceReq.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1479290_1
            receptionServiceReq.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:1479350_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1479293_1
            receptionServiceReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1479294_1
            receptionServiceReq.setContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1479296_1
            receptionServiceReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:1494120_1
        }

        /*M3执行第四接收字段（特殊方法）[8259]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getOriginalRoleMemberId(), "D3执行记录想法(公共)-M3执行第四接收字段（特殊方法）-身份人员ID不能为空", false);
        Assert.isNull(receptionServiceReq.getUserId(), "D3执行记录想法(公共)-M3执行第四接收字段（特殊方法）-账号ID不能为空", false);
        Assert.isNull(receptionServiceReq.getCreateInductionId(), "D3执行记录想法(公共)-M3执行第四接收字段（特殊方法）-创建人就职记录ID不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3执行记录想法(公共)-M3执行第四接收字段（特殊方法）-创建于空间ID不能为空", false);
        Assert.isNull(receptionServiceReq.getAppId(), "D3执行记录想法(公共)-M3执行第四接收字段（特殊方法）-创建于联盟应用ID不能为空", false);
        Assert.isNull(receptionServiceReq.getContent(), "D3执行记录想法(公共)-M3执行第四接收字段（特殊方法）-消息内容不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField(), "D3执行记录想法(公共)-M3执行第四接收字段（特殊方法）-自定义字段不能为空", false);
        receptionServiceRes = nbIntelligentCommunication.implementFourthReceivingField(receptionServiceReq);


//步骤1: D2执行判断想法类型(公共) - implementDetermineTypeIdeaCom
        ImplementDetermineTypeIdeaComRespDto implementDetermineTypeIdeaComRespDto = null;
        ImplementDetermineTypeIdeaComReqDto implementDetermineTypeIdeaComReqDto = new ImplementDetermineTypeIdeaComReqDto();
        if (reqDto != null) {
            implementDetermineTypeIdeaComReqDto.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:1495342_1
        }

        /*D2执行判断想法类型(公共)[8324]   */
        Assert.isNull(implementDetermineTypeIdeaComReqDto.getCustomField(), "D3执行记录想法(公共)-D2执行判断想法类型(公共)-自定义字段不能为空", false);
        implementDetermineTypeIdeaComRespDto = fwCompIntelligentCommunicationClient.implementDetermineTypeIdeaCom(implementDetermineTypeIdeaComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤2: M3执行业务应用公共字段推送内存（特殊方法） - implementBizPublicFieldPushMemory
        //ModelCode: publicFieldCache
        ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
        ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq = new ImplementBizPublicFieldPushMemoryReqDto();
        if (reqDto != null) {
            publicFieldCacheReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1479348_1
            publicFieldCacheReq.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1479349_1
            publicFieldCacheReq.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:1479344_1
            publicFieldCacheReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1479345_1
            publicFieldCacheReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1479346_1
        }

        /*M3执行业务应用公共字段推送内存（特殊方法）[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
        Assert.isNull(publicFieldCacheReq.getOriginalRoleMemberId(), "D3执行记录想法(公共)-M3执行业务应用公共字段推送内存（特殊方法）-身份人员ID不能为空", false);
        Assert.isNull(publicFieldCacheReq.getUserId(), "D3执行记录想法(公共)-M3执行业务应用公共字段推送内存（特殊方法）-账号ID不能为空", false);
        publicFieldCacheRes = nbIntelligentCommunication.implementBizPublicFieldPushMemory(publicFieldCacheReq);


//步骤3: D2执行时间格式化(公共) - implementDateFormatCom
        ImplementDateFormatComRespDto implementDateFormatComRespDto = null;
        ImplementDateFormatComReqDto implementDateFormatComReqDto = new ImplementDateFormatComReqDto();
        implementDateFormatComReqDto.setComTimeField(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1479309_1
        implementDateFormatComReqDto.setTimeFormatMode("yyyy-MM-dd");//CUSTOM_CONVENTION//sourceId:1479310_1

        /*D2执行时间格式化(公共)[8203]   */
        Assert.isNull(implementDateFormatComReqDto.getComTimeField(), "D3执行记录想法(公共)-D2执行时间格式化(公共)-通用时间字段不能为空", false);
        Assert.isNull(implementDateFormatComReqDto.getTimeFormatMode(), "D3执行记录想法(公共)-D2执行时间格式化(公共)-时间格式模式不能为空", false);
        implementDateFormatComRespDto = interfaceModeService.implementDateFormatCom(implementDateFormatComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤4: D1-2查询个人资料详情(公共) - queryUserInfoDetailCom
        QueryUserInfoDetailComRespDto queryUserInfoDetailComRespDto = null;
        QueryUserInfoDetailComReqDto queryUserInfoDetailComReqDto = new QueryUserInfoDetailComReqDto();
        if (reqDto != null) {
            queryUserInfoDetailComReqDto.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1479312_1
        }

        /*D1-2查发送人头像、姓名[408]   */
        Assert.isNull(queryUserInfoDetailComReqDto.getUserId(), "D3执行记录想法(公共)-D1-2查发送人头像、姓名-账号不能为空", false);
        queryUserInfoDetailComRespDto = fwBaseUserClient.queryUserInfoDetailCom(queryUserInfoDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤5: D3执行生成消息及数量(公共) - implementCreateMsgAndNumCom
        ImplementCreateMsgAndNumComRespDto implementCreateMsgAndNumComRespDto = null;
        if (implementDetermineTypeIdeaComRespDto != null) {
            ImplementCreateMsgAndNumComReqDto implementCreateMsgAndNumComReqDto = new ImplementCreateMsgAndNumComReqDto();
            implementCreateMsgAndNumComReqDto.setMsgAndLocUsageScene("WORK_TASK_SCENE");//sourceId:1479091_1
            implementCreateMsgAndNumComReqDto.setSendMsgTechnologyMode("LABOUR_SEND_NULL");//sourceId:1479094_1
            implementCreateMsgAndNumComReqDto.setMessageReceiverType("BY_APPOINT_MEM");//sourceId:1479093_1
            implementCreateMsgAndNumComReqDto.setNewTableTypeCode("OMS_FRAMEWORK_ORIGINAL_ROLE_MEMBER");//sourceId:1479095_1
            implementCreateMsgAndNumComReqDto.setMsgTableTypeCode("OMS_FRAMEWORK_ORIGINAL_ROLE_MEMBER");//sourceId:1479109_1
            implementCreateMsgAndNumComReqDto.setPlatformReplace("FALSE");//sourceId:1479126_1
            implementCreateMsgAndNumComReqDto.setHandleType("NO_NEED_HANDLING");//sourceId:1479123_1
            implementCreateMsgAndNumComReqDto.setMessageLocationCode("RECORD_IDEAS");//CUSTOM_CONVENTION//sourceId:1479121_1
            implementCreateMsgAndNumComReqDto.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1479127_1
            implementCreateMsgAndNumComReqDto.setMsgChannelClassCode("IDEA");//sourceId:1479119_1
            implementCreateMsgAndNumComReqDto.setMessageChannelTypeCode("PERSONAL_IDEA_SESSION");//sourceId:1479120_1
            implementCreateMsgAndNumComReqDto.setFirstFieldName("content");//CUSTOM_CONVENTION//sourceId:1479100_1
            implementCreateMsgAndNumComReqDto.setSecondFieldName("idCardName");//CUSTOM_CONVENTION//sourceId:1479102_1
            implementCreateMsgAndNumComReqDto.setThirdFieldName("todayDate");//CUSTOM_CONVENTION//sourceId:1479104_1
            if (implementDetermineTypeIdeaComRespDto != null) {
                implementCreateMsgAndNumComReqDto.setSendMsgScene(implementDetermineTypeIdeaComRespDto.getSendMsgScene());//SimpleFieldAssign//sourceId:1479092_1
                implementCreateMsgAndNumComReqDto.setMessageTemplateCode(implementDetermineTypeIdeaComRespDto.getMessageTemplateCode());//SimpleFieldAssign//sourceId:1479122_1
                implementCreateMsgAndNumComReqDto.setMsgTitleTemplateSemanticEngineCode(implementDetermineTypeIdeaComRespDto.getMsgTitleTemplateSemanticEngineCode());//SimpleFieldAssign//sourceId:1479106_1
                implementCreateMsgAndNumComReqDto.setTitleFieldName(implementDetermineTypeIdeaComRespDto.getTitleFieldName());//SimpleFieldAssign//sourceId:1479107_1
                implementCreateMsgAndNumComReqDto.setTitleFieldValue(implementDetermineTypeIdeaComRespDto.getTitleFieldValue());//SimpleFieldAssign//sourceId:1479108_1
            }
            if (reqDto != null) {
                implementCreateMsgAndNumComReqDto.setNewEntityId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1479096_1
                implementCreateMsgAndNumComReqDto.setMsgEntiyId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1479110_1
                implementCreateMsgAndNumComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1479099_1
                implementCreateMsgAndNumComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1479111_1
                implementCreateMsgAndNumComReqDto.setFirstFieldValue(reqDto.getContent());//SimpleFieldAssign//sourceId:1479101_1
            }
            if (queryUserInfoDetailComRespDto != null) {
                implementCreateMsgAndNumComReqDto.setSecondFieldValue(queryUserInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1479103_1
            }
            if (implementDateFormatComRespDto != null) {
                implementCreateMsgAndNumComReqDto.setThirdFieldValue(implementDateFormatComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:1479105_1
            }

            /*D3执行生成消息及数量(公共)[8243]   */
            Assert.isNull(implementCreateMsgAndNumComReqDto.getMsgAndLocUsageScene(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息及位置使用场景不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getSendMsgScene(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-发送消息场景不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getSendMsgTechnologyMode(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-发送消息技术模型不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getMessageReceiverType(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息接收方类型不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getNewTableTypeCode(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-通道归属主体内容类型编码不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getNewEntityId(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-通道归属主体内容ID不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getMsgTableTypeCode(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息内容表类型编码不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getMsgEntiyId(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息内容表主键ID不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getSpaceId(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-创建于空间ID不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getAppId(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-创建于联盟应用ID不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getPlatformReplace(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-是否平台代操作不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getHandleType(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-处理类型不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getMessageLocationCode(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息位置标识不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getMessageImportantLevel(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息重要紧急度层级不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getMsgChannelClassCode(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息使用通道类别不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getMessageChannelTypeCode(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-通道类型编码不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getMessageTemplateCode(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息模板标识不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getMsgTitleTemplateSemanticEngineCode(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息标题模板引擎标识不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getTitleFieldName(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-标题字段字段名不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getTitleFieldValue(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-标题字段字段值不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getFirstFieldName(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-第一个字段字段名不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getFirstFieldValue(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-第一个字段字段值不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getSecondFieldName(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-第二个字段字段名不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getSecondFieldValue(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-第二个字段字段值不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getThirdFieldName(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-第三个字段字段名不能为空", false);
            Assert.isNull(implementCreateMsgAndNumComReqDto.getThirdFieldValue(), "D3执行记录想法(公共)-D3执行生成消息及数量(公共)-第三个字段字段值不能为空", false);
            implementCreateMsgAndNumComRespDto = messageService.implementCreateMsgAndNumCom(implementCreateMsgAndNumComReqDto)/*vcase invoke isSameApp*/;


            implementCreateMsgAndNumComRespDto_1 = implementCreateMsgAndNumComRespDto;
        }

        ImplementRecordIdeasComRespDto retData = new ImplementRecordIdeasComRespDto();
        if (implementCreateMsgAndNumComRespDto_1 != null) {
            retData.setMessageId(implementCreateMsgAndNumComRespDto_1.getMessageId());//SimpleFieldAssign//sourceId:1508203_1
            retData.setMessageChannelId(implementCreateMsgAndNumComRespDto_1.getMessageChannelId());//SimpleFieldAssign//sourceId:1508204_1
            retData.setMemberChannelRelationId(implementCreateMsgAndNumComRespDto_1.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1508205_1
        }


        return retData;
    }
    //
}
